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