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