llvm::SmallDenseMap<Value, unsigned, 4> exceptions;
  unsigned operand_idx = 0;
  for (Value arg : op.getValues()) {
    Operation* arg_op = arg.getDefiningOp();
    if (arg_op && arg_op->getName() == first_arg_op->getName()) {
      ++operand_idx;
      continue;
    }
    exceptions[arg] = operand_idx++;
  }
  // Recall those inputs to the concat op that are not produced by a binary op

    }
  }
}

// Evaluate `operand_idx` w.r.t. `op`'s operands. If `operand_idx` is a positive
// number or a zero, it is returned as it is. If it is a negative number, it
// means it is counting backwards and will return the zero-based operand index
// for `op`.
//
// `operand_idx` should be within the range: [-num_operands, num_operands - 1].
int EvaluateOperandIdx(const int operand_idx, Operation& op) {
  if (operand_idx < 0) {

//
template <int QuantDim, int OperandIndex = 1>
class AffineOpCoefficient {
 public:
  template <typename ConcreteType>
  class Impl
      : public TraitBase<ConcreteType,
                         AffineOpCoefficient<QuantDim, OperandIndex>::Impl> {
   public:
    static int GetCoefficientOperandIndex() { return OperandIndex; }
    static int GetQuantizationDim() { return QuantDim; }
  };

    // Look for quantized dimension specs for each quantized type and
    // populate `coeff_op_quant_dim`.
    for (const auto& [operand_idx, quantized_type] :
         static_range_ptq_spec.input_quantized_types()) {
      if (quantized_type.has_dimension_specs()) {
        spec.coeff_op_quant_dim[operand_idx] =
            quantized_type.dimension_specs().dimension();
      }
    }
  }
}

}  // namespace

  absl::flat_hash_set<int> quantizable_operands = GetQuantizableOperands(op);
  if (quantizable_operands.empty()) return failure();

  bool has_change = false;
  for (auto operand_idx : quantizable_operands) {
    Value operand = op->getOperand(operand_idx);
    Operation* preceding_op = operand.getDefiningOp();
    if (!preceding_op || isa<TF::ConstOp>(preceding_op)) continue;

    int preceding_result_idx = -1;

              llvm::dyn_cast_or_null<tf_device::ParallelExecuteOp>(parent)) {
        int operand_idx = use->getOperandNumber();
        auto execute_results = execute.GetRegionOutputs(
            device_return->getParentRegion()->getRegionNumber());
        if (operand_idx >= execute_results.size()) return nullptr;

        auto result_from_use = execute_results[operand_idx];
        if (!result_from_use.hasOneUse()) return nullptr;

           << " operand, but island returns " << result_count;
  for (int operand_idx : llvm::seq<int>(0, yield.getNumOperands())) {
    if (island.getResult(operand_idx).getType() !=
        yield.getOperand(operand_idx).getType())
      return yield.emitOpError()
             << "operand #" << operand_idx << " type mismatch island results";
  }

    Type operand_type = operand_type_and_idx.value();
    int32_t operand_idx = operand_type_and_idx.index();
    for (int32_t i = n * operand_idx, e = i + n; i < e; ++i)
      if (failed(VerifyCompatibleTypes(operand_type, op.getType(i))))
        return op.emitOpError() << "incompatible types for result " << i
                                << " and terminator operand " << operand_idx;
  }

  return success();
}

      device_cluster.GetBody().getTerminator());

  for (OpOperand& operand : return_op->getOpOperands()) {
    auto operand_idx = operand.getOperandNumber();
    return_operand_map[return_op.getOperand(operand_idx)].push_back(
        operand_idx);
  }
  // `return_value_from_host` and `return_value_from_device` together contain

           << " operand, but control_node returns " << result_count;
  for (const int operand_idx : llvm::seq<int>(0, yield.getNumOperands())) {
    if (control_node.getResult(operand_idx).getType() !=
        yield.getOperand(operand_idx).getType())
      return yield.emitOpError() << "operand #" << operand_idx
                                 << " type mismatch control_node results";
  }
  return success();
}