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