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