}
		switch fv.Type().Kind() {
		case reflect.String:
			realMap[fieldInfo.name] = fv.String()
		case reflect.Bool:
			realMap[fieldInfo.name] = fv.Bool()
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			realMap[fieldInfo.name] = fv.Int()
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			realMap[fieldInfo.name] = fv.Uint()
		case reflect.Float32, reflect.Float64:

	}, {
		name:       "valid Real-Ip",
		realIP:     "2.2.2.2",
		remoteAddr: "1.2.3.4",
		expected:   []string{"2.2.2.2", "1.2.3.4"},
	}, {
		name:       "redundant Real-Ip",
		realIP:     "1.2.3.4",
		remoteAddr: "1.2.3.4",
		expected:   []string{"1.2.3.4"},
	}, {
		name:         "valid Real-Ip with forwarded-for",
		realIP:       "2.2.2.2",
		forwardedFor: "120.120.120.126,4.5.6.7",
		remoteAddr:   "1.2.3.4",

LogicalResult UnwrapTFCustomOps(func::FuncOp fn, OpBuilder& builder) {
  llvm::SmallVector<Operation*, 4> wrapped_ops;
  fn.walk([&](TFL::CustomTfOp custom_op) {
    auto* real_op = &custom_op.getBody().front().front();
    wrapped_ops.push_back(real_op);
  });

  for (auto* op : wrapped_ops) {
    auto parent_op = op->getParentOfType<TFL::CustomTfOp>();
    if (!parent_op) continue;
    builder.setInsertionPoint(parent_op);

    const UniformQuantizedValueConverter &converter) {
  return realFPElementsAttr.mapValues(
      quantizedElementType.getStorageType(),
      [&converter](const APFloat &realVal) {
        return converter.quantizeFloatToInt(realVal);
      });
}

/// Converts a real expressed SplatElementsAttr to a corresponding
/// SplatElementsAttr containing quantized storage values assuming the given

	rootCmd.Flags().StringVarP(&output, "outputFile", "o", "features.gen.go", "output Go file with labels as string consts")
}

// Parses a map in the yaml file
func readMap(m map[any]any, path []string) []string {
	var labels []string
	for k, v := range m {
		// If we see "values," then the element is a root and we shouldn't put it in our label name
		if k == "values" {

			if r != 0 {
				return r
			}
			return cmp.Compare(a.value, b.value)
		})
		return entries
	}

	got := readMap(out)
	want := readMap(in)
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("\nEncode: %v\nDecode: %v", want, got)
	}
}

func TestDecodePartial(t *testing.T) {
	type T struct {
		X []int
		Y string
	}

	var buf bytes.Buffer

      TypeID::get<TF::MatrixBandPartOp>(),
      TypeID::get<TF::MaxPool3DGradOp>(),
      TypeID::get<TF::PreventGradientOp>(),
      TypeID::get<TF::RandomShuffleOp>(),
      TypeID::get<TF::RealOp>(),
      TypeID::get<TF::ReciprocalOp>(),
      TypeID::get<TF::ReluOp>(),
      TypeID::get<TF::Relu6Op>(),
      TypeID::get<TF::ReluGradOp>(),
      TypeID::get<TF::RsqrtOp>(),
      TypeID::get<TF::SelectOp>(),

  CustomTfOpAdaptor op(operands, attr, properties, regions);

  if (op.getRegions().empty()) return success();
  auto* real_op = &op.getBody().front().front();
  if (llvm::isa<TF::FakeQuantWithMinMaxArgsOp, TF::FakeQuantWithMinMaxVarsOp,
                TF::FakeQuantWithMinMaxVarsPerChannelOp>(real_op)) {
    Value input = *operands.begin();
    inferredReturnTypes.assign({input.getType()});
  }
  return success();
}