auto new_dq_op = rewriter.create<quantfork::DequantizeCastOp>(
        new_q_op.getLoc(), transpose_op.getResult().getType(),
        new_q_op.getResult());
    transpose_op.getResult().replaceAllUsesWith(new_dq_op.getResult());
    new_q_op.setOperand(transpose_op.getResult());

    return success();
  }
};

}  // namespace TFL
}  // namespace mlir

    for (Operation *user :
         make_early_inc_range(variable_v2_op.getResult().getUsers())) {
      builder.setInsertionPoint(user);
      ReadVariableOp read_variable_op = builder.create<ReadVariableOp>(
          user->getLoc(), ArrayRef<Type>{tensor_type},
          ArrayRef<Value>{var_handle_op});
      user->getResult(0).replaceAllUsesWith(read_variable_op.getResult());
      user->erase();
    }
    variable_v2_op.erase();
  }

      if (llvm::isa<tf_device::LaunchOp>(parent)) {
        new_value = parent->getResult(operand.getOperandNumber());
      } else if (auto replicate =
                     llvm::dyn_cast<tf_device::ReplicateOp>(parent)) {
        int n = replicate.getN();
        new_value = parent->getResult(operand.getOperandNumber() * n);
      } else {
        parent->emitOpError("Unsupported wrapper op.");

  // Omit any bias and requantize ops as `tfl.{gemm_op}` outputs a
  // fused `qi8` type.
  rewriter.replaceAllUsesWith(uniform_quantize_op->getResult(0),
                              op->getResult(0));
  return op->getResult(0).getType().cast<TensorType>().clone(
      new_result_quantized_type);
}

// Matches kernel dimension numbers, ranks of input and output and constant

    if (!req_op) return failure();

    // Create a new func.call op with f32 output.
    auto new_call_op = call_op.clone();
    new_call_op->getResult(0).setType(
        mlir::cast<ShapedType>(call_op.getResult(0).getType())
            .clone(rewriter.getF32Type()));
    rewriter.setInsertionPoint(call_op);
    rewriter.insert(new_call_op);

    if (clobber_first) {
      dequant_op.setOperand(requantize_op.getResult());
      // All ops requiring this value already use the result of dequant.
      clobber_first = false;
    } else {
      auto new_dequant_op = builder_.create<quantfork::DequantizeCastOp>(
          loc, dequant_op.getResult().getType(), requantize_op.getResult());
      for (auto [op, operand_idx] : state.users) {

    auto new_gather_op = rewriter.create<TFL::GatherOp>(
        op.getLoc(),
        /*result=*/
        mlir::cast<TensorType>(op.getResult().getType())
            .clone(builder.getI4Type()),
        /*operand=*/op.getOperands(), op->getAttrs());
    rewriter.replaceAllUsesWith(op.getResult(), new_gather_op.getResult());

    return success();
  }
};

class ReduceTypePrecisionPass

            q_op.getResult().use_begin()->getOwner());
        quantize_op->setOperand(quantize_operand_num, dq_op);
        return false;
      }
    }
    rewriter.setInsertionPointAfter(op);
    auto q = rewriter.create<quantfork::QuantizeCastOp>(op->getLoc(), cast_type,
                                                        op.getResult());

 */

package org.gradle.tooling.events.task;

import org.gradle.tooling.events.FinishEvent;

/**
 * An event that informs about a task having finished its execution. You can query the result of the task using {@link #getResult()}.
 *
 * @since 2.5
 */
public interface TaskFinishEvent extends TaskProgressEvent, FinishEvent {

    /**

  auto mul_op =
      rewriter.create<TF::MulOp>(squared_diff_op.getLoc(), result_type,
                                 sub_op.getResult(), sub_op.getResult());
  rewriter.replaceOp(squared_diff_op, mul_op.getResult());

  return success();
}

// ================== split ========================

LogicalResult UnrollSplit::matchAndRewrite(TFL::SplitOp split_op,