// 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

    auto resize = rewriter.create<TFL::ResizeNearestNeighborOp>(
        gather_nd_first->getLoc(), transpose_second.getResult().getType(),
        reshape_op.getResult(), size_const_op.getResult(), false, false);

    rewriter.replaceOp(transpose_second, resize.getResult());
    return success();
  }
};

// Fuse Add with proceeding FullyConnected.

        loc, transposed_output_2d_shape, transposed_image_2d_op.getResult(),
        transposed_kernel_2d_op.getResult(), window_strides_2d, padding_2d,
        lhs_dilation_2d, rhs_dilation_2d, window_reversal_2d, dnums_2d,
        conv_op.getFeatureGroupCount(), conv_op.getBatchGroupCount(),
        conv_op.getPrecisionConfigAttr());

    OpResult conv2d_output = conv2d_op->getResult(0);

        Operation* parent = yield->getParentOp();
        add_to_worklist(parent->getResult(use.getOperandNumber()));
        continue;
      }
      // TODO(jpienaar): This can be generalized.
      if (isa<IdentityOp, IdentityNOp, StopGradientOp>(use.getOwner())) {
        add_to_worklist(use.getOwner()->getResult(use.getOperandNumber()));
        continue;
      }

  auto shuffled_paddings_op = builder.create<TF::ConstOp>(getLoc(), values);

  // Use new paddings.
  setOperand(1, shuffled_paddings_op);

  // Change the result type.
  getResult().setType(ShuffleRankedTensorType(getResult().getType(),
                                              ReversePermutation(permutation))
                          .cast<TensorType>());

  return success();
}

  // Replace original concat with an unary op.
  OperationState new_unary_op_state(loc, first_arg_op->getName().getStringRef(),
                                    concat_unary_operands.getResult(),
                                    op.getResult().getType(),
                                    ArrayRef<NamedAttribute>());
  Operation* new_unary_op = rewriter.create(new_unary_op_state);

        ba.replaceAllUsesWith(value);
        cond_block.getArgument(arg_no).replaceAllUsesWith(value);

        // This could be relaxed and casts inserted.
        if (while_op.getResult(arg_no).getType() == value.getType())
          while_op.getResult(arg_no).replaceAllUsesWith(value);
      }
    }

    // The While ops operands and result types need to match
    SmallVector<Value, 4> new_operands;

// when used as element types.
class TFL_TFTypesWithSameBits<int i, int j, int num> :
  And<[
    Or<[CPred<"getElementTypeOrSelf($_op.getResult(" # i # ")).isa<mlir::TF::Quint" # num # "Type>()">,
        CPred<"getElementTypeOrSelf($_op.getResult(" # i # ")).isUnsignedInteger(" # num # ")">]>,
    Or<[CPred<"getElementTypeOrSelf($_op.getOperand(" # j # ")).isa<mlir::TF::Quint" # num # "Type>()">,

    // Collect mapping of OutputTensor to associated block arg.
    arg_nodes_to_values.try_emplace({arg_node.node, arg_node.index}, arg_def);
    island->getResult(0).replaceAllUsesWith(arg_def);
    // Erase control outputs from feed.
    auto control_uses = island->getResult(1).getUses();
    for (auto& control_use : llvm::make_early_inc_range(control_uses))
      control_use.getOwner()->eraseOperand(control_use.getOperandNumber());

HSPLkotlinx/coroutines/CancellableContinuationImpl;->getExceptionalResult$kotlinx_coroutines_core(Ljava/lang/Object;)Ljava/lang/Throwable;
HSPLkotlinx/coroutines/CancellableContinuationImpl;->getResult()Ljava/lang/Object;
HSPLkotlinx/coroutines/CancellableContinuationImpl;->getSuccessfulResult$kotlinx_coroutines_core(Ljava/lang/Object;)Ljava/lang/Object;
HSPLkotlinx/coroutines/CancellableContinuationImpl;->initCancellability()V