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