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