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