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