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