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