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