<y:Arrows source="delta" target="none"/>
        </y:QuadCurveEdge>
      </data>
    </edge>
    <edge id="e1" source="n5" target="n4">
      <data key="d9">
        <y:QuadCurveEdge straightness="0.1">
          <y:Path sx="70.0" sy="-0.0" tx="-70.0" ty="-10.0"/>
          <y:LineStyle color="#000000" type="line" width="1.0"/>
          <y:Arrows source="delta" target="none"/>
        </y:QuadCurveEdge>

	return image.DecodeConfig(bufio.NewReader(f))
}

func delta(u0, u1 uint32) int {
	d := int(u0) - int(u1)
	if d < 0 {
		return -d
	}
	return d
}

func withinTolerance(c0, c1 color.Color, tolerance int) bool {
	r0, g0, b0, a0 := c0.RGBA()
	r1, g1, b1, a1 := c1.RGBA()
	r := delta(r0, r1)
	g := delta(g0, g1)
	b := delta(b0, b1)
	a := delta(a0, a1)

  })";

  CellReader<int64_t> error(kHasTpuPartitionedCallStreamzName);
  CreateModule(kMlirModuleStr);

  auto result = Run();

  EXPECT_TRUE(result.succeeded());

  EXPECT_EQ(error.Delta("true"), 1);
  EXPECT_EQ(error.Delta("false"), 0);
}

TEST_F(InferenceMetricsPassTest, RecordsFalseForNonTPUPartitionedCallOp) {
  static constexpr char kMlirModuleStr[] = R"(

	ScrapeTypeEnvoy = "envoy"
	ScrapeTypeApp   = "application"
	ScrapeTypeAgent = "agent"
)

var processStartTime = time.Now()

func RecordStartupTime() {
	delta := time.Since(processStartTime)
	startupTime.Record(delta.Seconds())
	log.Infof("Readiness succeeded in %v", delta)

  }

  /**
   * Adds {@code delta} to the value currently associated with {@code key}, and returns the new
   * value.
   */
  @CanIgnoreReturnValue
  public long addAndGet(K key, long delta) {
    outer:
    while (true) {
      AtomicLong atomic = map.get(key);
      if (atomic == null) {
        atomic = map.putIfAbsent(key, new AtomicLong(delta));
        if (atomic == null) {

  EXPECT_TRUE(result.ok());
  EXPECT_EQ(compilation_status.Delta(kMlirCombinedMlirSuccess), 1);
  EXPECT_EQ(compilation_status.Delta(kMlirCombinedMlirFailure), 0);
  EXPECT_EQ(compilation_status.Delta(kMlirCombinedOldSuccess), 1);
  EXPECT_EQ(compilation_status.Delta(kMlirCombinedOldFailure), 0);
  // Old bridge should never be called at all.
  EXPECT_EQ(compilation_status.Delta(kOldBridgeMlirFilteredFailure), 0);

          <y:Arrows source="delta" target="none"/>
        </y:QuadCurveEdge>
      </data>
    </edge>
    <edge id="e1" source="n3" target="n6">
      <data key="d9">
        <y:QuadCurveEdge straightness="0.1">
          <y:Path sx="70.0" sy="7.5" tx="-70.0" ty="-0.0"/>
          <y:LineStyle color="#000000" type="line" width="1.0"/>
          <y:Arrows source="delta" target="none"/>
        </y:QuadCurveEdge>

          <y:Arrows source="delta" target="none"/>
        </y:QuadCurveEdge>
      </data>
    </edge>
    <edge id="e1" source="n5" target="n4">
      <data key="d9">
        <y:QuadCurveEdge straightness="0.1">
          <y:Path sx="70.0" sy="-0.0" tx="-70.0" ty="-10.0"/>
          <y:LineStyle color="#000000" type="line" width="1.0"/>
          <y:Arrows source="delta" target="none"/>
        </y:QuadCurveEdge>

	if _, ok := m1.(*image.Gray); !ok {
		t.Errorf("got %T, want *image.Gray", m1)
	}
	// Compare the average delta to the tolerance level.
	want := int64(2 << 8)
	if got := averageDelta(m0, m1); got > want {
		t.Errorf("average delta too high; got %d, want <= %d", got, want)
	}
}

// averageDelta returns the average delta in RGB space. The two images must
// have the same bounds.
func averageDelta(m0, m1 image.Image) int64 {

}

//go:nosplit
//go:noinline
func LoadAcquintptr(ptr *uintptr) uintptr {
	return *ptr
}

//go:noescape
func Xadd64(ptr *uint64, delta int64) uint64

//go:noescape
func Xadduintptr(ptr *uintptr, delta uintptr) uintptr

//go:noescape
func Xadd(ptr *uint32, delta int32) uint32

//go:noescape
func Xchg64(ptr *uint64, new uint64) uint64

//go:noescape
func Xchg(ptr *uint32, new uint32) uint32