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