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