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