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