DenseMap<QuantizationDriver::OpWithResultIndex,
             QuantizationDriver::QuantStateIndex>& result_states) {
  const auto [cached, inserted] = value_to_state.try_emplace(value, 0);
  if (!inserted) {
    if (as_result) {
      result_states[{op, index}] = cached->second;
    } else {
      operand_states[{op, index}] = cached->second;
    }
    return;
  }

    // are the values from `operand_states_` and `result_state_`.
    std::unordered_map<int, RequantizeState> rescale_states_;

    // Maps of indexes to the propagation state vector from the ops operands,
    // results and arguments.
    llvm::DenseMap<OpValue, int> operand_states_;
    llvm::DenseMap<OpValue, int> result_states_;
  };

  func::FuncOp func_;

  DeviceTarget target_spec_;

  void Finalize();

  SmallVector<BlockArgument, 4> GetArgs() { return args_; }

  llvm::DenseMap<std::pair<mlir::Operation*, int>, int> GetResultStates() {
    return result_states_;
  }

  DenseMap<OpWithResultIndex, QuantStateIndex> result_states_;

  // Returns the state of the block argument.
  QuantState& GetArgQuantState(BlockArgument arg) {
    return states_[arg_states_[arg]];
  }

                                : mlir::TF::kMlirPh1BridgeCounterNonReplicated;
  auto result_status = diag_handler.ConsumeStatus();
  TF_RETURN_IF_ERROR(
      RecordIfErrorStatus(/*error_prefix=*/"lower_cluster_to_runtime",
                          bridge_type, xla_device_type, result_status));

  return absl::OkStatus();
}

// TODO(b/305211853): Unify the CPU/TPU/GPU Execution Ops and thus these two

	}

	for _, test := range tests {
		resultStatus, exists := GetContainerStatus(test.status, test.name)
		assert.Equal(t, test.expected.status, resultStatus, "GetContainerStatus: "+test.desc)
		assert.Equal(t, test.expected.exists, exists, "GetContainerStatus: "+test.desc)

		resultStatus = GetExistingContainerStatus(test.status, test.name)
		assert.Equal(t, test.expected.status, resultStatus, "GetExistingContainerStatus: "+test.desc)
	}
}

      params_attr.cast<TypeAttr>().getValue().dyn_cast<QuantParams>();
  bool immutable = !EmptyParams(params);
  int next_state_index = states_.size();
  states_.push_back({params, immutable});
  if (as_result) {
    result_states_.insert({{op, index}, next_state_index});
  } else {
    operand_states_.insert({{op, index}, next_state_index});
  }
  return next_state_index;
}

                                         getElementTypeOrSelf(filter_type))
                                         .getScales();
    std::vector<double> result_scales;
    result_scales.reserve(filter_scales.size());

    for (const double filter_scale : filter_scales) {
      result_scales.push_back(input_scale * filter_scale);
    }

    const ArrayRef<int64_t> zero_points =
        mlir::cast<UniformQuantizedPerAxisType>(

    StrAttr:$call_target_name,
    StrAttr:$backend_config,
    BoolAttr:$has_side_effect,
    TF_ShapeAttrArray:$result_shapes
  );

  let results = (outs
    Variadic<TF_Tensor>:$results
  );

  TF_DerivedOperandTypeListAttr operand_dtypes = TF_DerivedOperandTypeListAttr<0>;

*   Tracing and Debugging:
    *   Add source, destination name to `_send` traceme to allow easier
        debugging.
    *   Add traceme event to `fastpathexecute`.
*   Other:
    *   Fix an issue with AUC.reset_states for multi-label AUC
        [#35852](https://github.com/tensorflow/tensorflow/issues/35852)
    *   Fix the TF upgrade script to not delete files when there is a parsing
        error and the output mode is `in-place`.