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