usesScratch       bool      // this op requires scratch memory space
	hasSideEffects    bool      // for "reasons", not to be eliminated.  E.g., atomic store, #19182.
	zeroWidth         bool      // op never translates into any machine code. example: copy, which may sometimes translate to machine code, is not zero-width.

  %1 = "tf.Const"() {value = dense<[0, 0x4141, 3, 1]> : tensor<4xi32>} : () -> tensor<4xi32>
  %2 = "tf.Transpose"(%arg0, %0) : (tensor<1x4x4x8xf32>, tensor<4xi32>) -> tensor<1x8x4x4xf32>
  // expected-error @+1 {{'tf.Transpose' op perm[1]=16705 must be in range [-4, 4)}}
  %3 = "tf.Transpose"(%2, %1) : (tensor<1x8x4x4xf32>, tensor<4xi32>) -> tensor<1x4x4x8xf32>
  func.return %3 : tensor<1x4x4x8xf32>

	[2]Op{OpAMD64MOVWload, OpAMD64LEAQ1}:  OpAMD64MOVWloadidx1,
	[2]Op{OpAMD64MOVWload, OpAMD64LEAQ2}:  OpAMD64MOVWloadidx2,
	[2]Op{OpAMD64MOVLload, OpAMD64LEAQ1}:  OpAMD64MOVLloadidx1,
	[2]Op{OpAMD64MOVLload, OpAMD64LEAQ4}:  OpAMD64MOVLloadidx4,
	[2]Op{OpAMD64MOVLload, OpAMD64LEAQ8}:  OpAMD64MOVLloadidx8,
	[2]Op{OpAMD64MOVQload, OpAMD64LEAQ1}:  OpAMD64MOVQloadidx1,
	[2]Op{OpAMD64MOVQload, OpAMD64LEAQ8}:  OpAMD64MOVQloadidx8,

        op, op.getOutput().getType(), op.getScales(), op.getZeroPoints(),
        /*expressed_type=*/rewriter.getF32Type(), op.getQuantizationMinVal(),
        op.getQuantizationMaxVal(), op.getQuantizationAxis(), rewriter);
    if (failed(output_type)) {
      return failure();
    }

    auto result = rewriter.create<mhlo::UniformQuantizeOp>(
        op->getLoc(), *output_type, op.getInput());

	op := &PortAllocationOperation{}
	op.pa = pa
	op.allocated = []int{}
	op.releaseDeferred = []int{}
	op.shouldRollback = true
	op.dryRun = dryRun
	return op
}

// Will rollback unless marked as shouldRollback = false by a Commit().  Call from a defer block
func (op *PortAllocationOperation) Finish() {
	if op.shouldRollback {
		op.Rollback()
	}
}

    << '(' << op.getArgs() << ')';

  fallback_common::PrintExecuteOpCommon(p, op);
  fallback_common::PrintExecuteOpFuncAttribute(p, op);
  if (!op.getResults().empty()) p << " : " << op.getResults().size();
}

void ExecuteOpSeqWithAllocator::print(OpAsmPrinter &p) {
  ExecuteOpSeqWithAllocator op = *this;
  p << "(" << op.getInOpChain() << ", " << op.getAllocator() << ") key("

      op.replaceAllUsesWith(op.getOperands());
      op.erase();
    }
  }
}

using LocalVarOp = std::variant<TF::VarHandleOp, TF::MlirLocalVarOp>;

Value LocalVarOp_resource(LocalVarOp &op) {
  if (auto var_handle_op = std::get_if<TF::VarHandleOp>(&op)) {
    return var_handle_op->getResource();
  } else {
    return std::get<TF::MlirLocalVarOp>(op).getResource();
  }
}

      isa<TF::TPUReplicatedInputOp>(op) || isa<TF::TPUReplicatedOutputOp>(op) ||
      isa<TF::TPUPartitionedInputOp>(op) ||
      isa<TF::TPUPartitionedInputV2Op>(op) ||
      isa<TF::TPUPartitionedOutputOp>(op) ||
      isa<TF::TPUPartitionedOutputV2Op>(op))
    return true;
  if (IsMustBeXlaOp(op, metadata_map) && IsMustNotBeXlaOp(op)) {
    // TODO(b/269195256#comment19) change the warning for Identity op to error

  LogicalResult match(stablehlo::ReshapeOp op) const override {
    return success(IsOpFullyQuantized(op));
  }

  void rewrite(stablehlo::ReshapeOp op,
               PatternRewriter& rewriter) const override {
    rewriter.replaceOpWithNewOp<TFL::ReshapeOp>(
        op, op.getOperand(),
        CreateI32ShapeConstantOp(op.getResult().getType(), op->getLoc(),
                                 rewriter));

  rewriter.replaceAllUsesWith(op.getResult(), output_transpose_op);
}

// "Climbs up" the `op` if `op` is a `BraodcastInDimOp` and returns the defining
// op of its operand. Returns `op` otherwise. May return `nullptr` when the
// `BroadcastInDimOp`'s operand is a block argument.
absl::Nullable<Operation*> SkipUpwardsOptionalBroadcastInDimOp(
    absl::Nonnull<Operation*> op) {