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