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