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