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