x192, x193 = bits.Sub64(x183, 0xffffffff00000000, uint64(p224Uint1(x191)))
	var x194 uint64
	var x195 uint64
	x194, x195 = bits.Sub64(x185, 0xffffffffffffffff, uint64(p224Uint1(x193)))
	var x196 uint64
	var x197 uint64
	x196, x197 = bits.Sub64(x187, 0xffffffff, uint64(p224Uint1(x195)))
	var x199 uint64
	_, x199 = bits.Sub64(x189, uint64(0x0), uint64(p224Uint1(x197)))
	var x200 uint64

	var x193 uint64
	var x194 uint64
	x194, x193 = bits.Mul64(x183, 0xffffffff00000000)
	var x195 uint64
	var x196 uint64
	x196, x195 = bits.Mul64(x183, 0xffffffff)
	var x197 uint64
	var x198 uint64
	x197, x198 = bits.Add64(x196, x193, uint64(0x0))
	var x199 uint64
	var x200 uint64
	x199, x200 = bits.Add64(x194, x191, uint64(p384Uint1(x198)))
	var x201 uint64
	var x202 uint64

				// entirely outside of the image's bounds. For example, this can
				// occur with a 4:2:0 chroma subsampling and a 1x1 image. Baseline
				// decoding works on the one 16x16 MCU as a whole; progressive
				// decoding's first pass works on that 16x16 MCU as a whole but
				// refinement passes only process one 8x8 block within the MCU.
				continue
			}

			for j := 0; j < 8; j++ {
				for i := 0; i < 8; i++ {

				hi := d.comp[compIndex].h
				vi := d.comp[compIndex].v
				for j := 0; j < hi*vi; j++ {
					// The blocks are traversed one MCU at a time. For 4:2:0 chroma
					// subsampling, there are four Y 8x8 blocks in every 16x16 MCU.
					//
					// For a sequential 32x16 pixel image, the Y blocks visiting order is:
					//	0 1 4 5
					//	2 3 6 7
					//
					// For progressive images, the interleaved scans (those with nComp > 1)

00000330  e4 2b 4c d9 d5 b3 79 83  d3 75 cc a4 47 01 74 0b  |.+L...y..u..G.t.|
00000340  35 84 be 59 bd 17 03 03  00 99 72 3e 53 38 42 12  |5..Y......r>S8B.|
00000350  6f 99 20 c4 98 59 48 61  e0 13 80 8e 96 25 96 f8  |o. ..YHa.....%..|
00000360  c9 c8 35 9c 35 c0 13 d7  34 24 0b 6e 59 4f 1b 77  |..5.5...4$.nYO.w|
00000370  1f 9a 71 6b 6b dc 71 23  b1 a2 e8 1e c2 a0 b1 8c  |..qkk.q#........|

	}
	origPtr := uint(br.ReadBits(24))

	// If not every byte value is used in the block (i.e., it's text) then
	// the symbol set is reduced. The symbols used are stored as a
	// two-level, 16x16 bitmap.
	symbolRangeUsedBitmap := br.ReadBits(16)
	symbolPresent := make([]bool, 256)
	numSymbols := 0
	for symRange := uint(0); symRange < 16; symRange++ {
		if symbolRangeUsedBitmap&(1<<(15-symRange)) != 0 {

			}
			yi := m.YOffset(sx, sy)
			ci := m.COffset(sx, sy)
			yBlock[8*j+i] = int32(m.Y[yi])
			cbBlock[8*j+i] = int32(m.Cb[ci])
			crBlock[8*j+i] = int32(m.Cr[ci])
		}
	}
}

// scale scales the 16x16 region represented by the 4 src blocks to the 8x8
// dst block.
func scale(dst *block, src *[4]block) {
	for i := 0; i < 4; i++ {
		dstOff := (i&2)<<4 | (i&1)<<2
		for y := 0; y < 4; y++ {
			for x := 0; x < 4; x++ {

- Document that ServiceTopology feature is required to use `service.spec.topologyKeys`. ([#96528](https://github.com/kubernet...

	var x195 uint64
	var x196 uint64
	x196, x195 = bits.Mul64(arg1[4], 0x400000000000)
	var x197 uint64
	var x198 uint64
	x197, x198 = bits.Add64(x181, x195, uint64(0x0))
	var x199 uint64
	var x200 uint64
	x199, x200 = bits.Add64(x183, x196, uint64(p521Uint1(x198)))
	var x201 uint64
	var x202 uint64

00000060  d1 56 18 67 59 a5 e1 ed  99 0f ca e5 6b 5f e3 d9  |.V.gY.......k_..|
00000070  e3 fd e6 a2 50 93 bf 87  85 60 e7 7f 0b a0 96 c4  |....P....`......|
00000080  29 55 63 de fe 6b 75 99  b2 a6 75 92 61 d0 96 19  |)Uc..ku...u.a...|
00000090  f5 60 8f ec e9 d3 98 4a  b9 6b 98 26 c1 3e 27 7e  |.`.....J.k.&.>'~|
000000a0  17 03 03 00 17 5a aa bb  35 67 ec 83 da 8e 85 bd  |.....Z..5g......|