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