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