int64_t axis) {
    assert(shape.size() == index.size());
    assert(axis < shape.size());
    assert(axis >= 0);
    assert(index[axis] == 0);
    offset_ = IndexToOffset(shape, index);
    stride_ = StrideForAxis(shape, axis);
    size_ = shape[axis];
  }

  // Returns the size of the 1-d slice across the tensor.
  int64_t size() const { return size_; }

        assertEquals(4, res.getVertices().size(), "wrong # of vertices in the resulting graph after resolver");
        assertEquals(
                2,
                res.getExcidentEdges(v1).size(),
                "wrong # of excident edges in the resulting graph entry after resolver");

        assertEquals(
                1,
                res.getIncidentEdges(v2).size(),

  EXPECT_EQ(clusters.count(kTarget0), 1);
  EXPECT_EQ(clusters[kTarget0].size(), 1);
  EXPECT_EQ(clusters[kTarget0][0].ops.size(), 2);

  constexpr StringRef kTarget1 = "tpu1";
  EXPECT_EQ(clusters.count(kTarget1), 1);
  EXPECT_EQ(clusters[kTarget1].size(), 1);
  EXPECT_EQ(clusters[kTarget1][0].ops.size(), 2);
}

TEST(BuildClusters, TestMergedClusters) {

		if err != nil {
			return nil, fmt.Errorf("invalid size of watch cache size: %s", c)
		}
		if size < 0 {
			return nil, fmt.Errorf("watch cache size cannot be negative: %s", c)
		}
		watchCacheSizes[schema.ParseGroupResource(tokens[0])] = size
	}
	return watchCacheSizes, nil
}

// WriteWatchCacheSizes turns a map of cache size values into a list of string specifications.

        List<StackTraceRelevance> frameRelevance,
        List<Failure> suppressed,
        List<Failure> causes
    ) {
        if (stackTrace.size() != frameRelevance.size()) {
            throw new IllegalArgumentException("stackTrace and frameRelevance must have the same size.");
        }

        this.original = original;
        this.stackTrace = ImmutableList.copyOf(stackTrace);

  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
        dim {
          size: 2
        }
        dim {
          size: 5
        }
        dim {
          size: 3
        }
      }
    }
  }
}
node {
  name: "Placeholder_1"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT

	for _, size := range []int{256, 1024, 4096, 16384} {
		src := bytes.Repeat([]byte{'2', 'b', '7', '4', '4', 'f', 'a', 'a'}, size/8)
		sink = make([]byte, size/2)

		b.Run(fmt.Sprintf("%v", size), func(b *testing.B) {
			b.SetBytes(int64(size))
			for i := 0; i < b.N; i++ {
				Decode(sink, src)
			}
		})
	}
}

func BenchmarkDecodeString(b *testing.B) {

			align = 4
		default:
			switch {
			case w.ctxt.Arch.PtrSize == 8 && s.Size%8 == 0:
				align = 8
			case s.Size%4 == 0:
				align = 4
			case s.Size%2 == 0:
				align = 2
			default:
				align = 1
			}
		}
	}
	if s.Size > cutoff {
		w.ctxt.Diag("%s: symbol too large (%d bytes > %d bytes)", s.Name, s.Size, cutoff)
	}
	o := &w.tmpSym
	o.SetName(name, w.Writer)
	o.SetABI(abi)

      newDelegate.addAll(delegate);
      this.table = newDelegate;
      return;
    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask

SUCCESS
-- trace --
Trace Go1.22
EventBatch gen=1 m=0 time=0 size=11
ProcStatus dt=1 p=1 pstatus=1
GoStatus dt=1 g=1 m=0 gstatus=3
GoSyscallEndBlocked dt=1
EventBatch gen=1 m=1 time=0 size=18
ProcStatus dt=1 p=2 pstatus=1
GoStatus dt=1 g=2 m=1 gstatus=2
ProcStatus dt=1 p=0 pstatus=4
ProcSteal dt=1 p=0 p_seq=1 m=0
EventBatch gen=1 m=18446744073709551615 time=0 size=5
Frequency freq=15625000