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