});

    std::vector<std::string> lines;
    lines.push_back("-------- Quantization Summary --------");
    lines.push_back("Number of quantized layers in the model");
    lines.push_back("--------------------------------");
    lines.push_back(
        absl::StrFormat("%s Count/Total", pad_string("Name", name_col_width)));
    lines.push_back("================================");

};

TEST_F(PjRtExecutionUtilGpuTest, PreparePjRtExecutableArguments) {
  std::vector<const Tensor*> inputs;
  inputs.push_back(CreateDeviceTensor<int32_t>(TensorShape({1, 3}), {0, 0, 0}));
  inputs.push_back(CreateDeviceTensor<int32_t>(TensorShape({1, 3}), {1, 2, 3}));
  inputs.push_back(CreateDeviceTensor<int32_t>(TensorShape({1, 3}), {4, 5, 6}));
  int num_missing_prefix_ctx_inputs = 2;
  std::vector<int> input_mapping{3, 4};

    if (aggregator_ops_to_ignore.count(op.getId().str())) continue;

    ids.push_back(op.getId());
    calibration_methods.push_back(op.getCalibrationMethod());
    statistics_outputs.push_back(op.getMin());
    statistics_outputs.push_back(op.getMax());
    statistics_outputs.push_back(op.getHistogram());
  }
}

// Inserts a `CalibrationStatisticsSaverOp` to the end of the region.

    if (value.IsBool()) {
      mlir_vector.push_back(BuildVhloBooleanV1Attr(value.AsBool(), builder));
    } else if (value.IsString()) {
      mlir_vector.push_back(
          BuildVhloStringV1Attr(value.AsString().str(), builder));
    } else if (value.IsInt()) {
      mlir_vector.push_back(BuildVhloIntV1Attr(value.AsInt64(), builder));
    } else if (value.IsFloat()) {
      mlir_vector.push_back(BuildVhloFloatV1Attr(value.AsFloat(), builder));

    input_arguments.push_back(tensor_i32);
    input_arguments.push_back(one_matrix->getResult(0));
    lhs_rank = tensor_shape.size();
    rhs_rank = opponent_shape.size();
  } else {
    output_shape =
        CreateOutputShape(reduce_dnums, opponent_shape, tensor_shape);
    input_arguments.push_back(one_matrix->getResult(0));
    input_arguments.push_back(tensor_i32);
    lhs_rank = opponent_shape.size();

      if (wordStart) {
        result.push_back(delimiter);
      }
      wordStart = true;
      continue;
    }
    if (!from_snake && isupper(c)) {
      wordStart = true;
    }

    // add delimiter
    if (wordStart && toSnake && !inputStart) {
      result.push_back(delimiter);
    }

    // add the next letter from the input string (choosing upper/lower case)

    std::vector<const Edge*> control_edges;
    std::vector<OutEdgeInfo> data_edges;
    for (auto e : n->out_edges()) {
      if (e->IsControlEdge()) {
        control_edges.push_back(e);
      } else {
        data_edges.push_back({e->dst(), e->src_output(), e->dst_input()});
      }
    }
    for (const Edge* e : control_edges) {
      g->AddControlEdge(original_node, e->dst());
      g->RemoveEdge(e);
    }

      control_fetches.push_back(value);
    } else {
      data_fetches.push_back(value);
      data_types.push_back(value.getType());
    }
  }
  auto island = OpBuilder(fetch).create<IslandOp>(
      fetch.getLoc(), data_types,
      /*control=*/ControlType::get(fetch.getContext()),
      /*controlInputs=*/control_fetches);
  island.getBody().push_back(new Block);

      transpose_ops.push_back(transpose);
    }
  }

  // Nothing to do here.
  if (!permutation_op || transpose_ops.empty()) return;
  SmallVector<int64_t, 4> permutation;
  auto perm_attr = mlir::cast<DenseElementsAttr>(permutation_op.getValue());
  for (const auto& value : perm_attr.getValues<APInt>())
    permutation.push_back(value.getSExtValue());

        const std::vector<std::string> indices =
            absl::StrSplit(node_specification, '-');
        for (const std::string& cur_index : indices) {
          custom_op_map[node_name].quantizable_input_indices.push_back(
              std::stoi(cur_index));
        }
        break;
      }
      case CustomOpUpdateOptions::kWeightOnly:
        custom_op_map[node_name].is_weight_only =
            GetBooleanSpecs(node_specification);