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

			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();
}