if size == 0 {
			// Some clients add a Range header to all requests to
			// limit the size of the response. If the file is empty,
			// ignore the range header and respond with a 200 rather
			// than a 416.
			ranges = nil
			break
		}
		w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", size))
		fallthrough
	default:
		serveError(w, err.Error(), StatusRequestedRangeNotSatisfiable)
		return
	}

		y = y[3+len(slice):]
	}

	return x, nil
}

func (m *certificateMsg) unmarshal(data []byte) bool {
	if len(data) < 7 {
		return false
	}

	certsLen := uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6])
	if uint32(len(data)) != certsLen+7 {
		return false
	}

	numCerts := 0
	d := data[7:]
	for certsLen > 0 {
		if len(d) < 4 {
			return false
		}

	c := ts.Client()
	res, err := c.Do(req)
	if err != nil {
		t.Fatal(err)
	}

	out, _ := io.ReadAll(res.Body)
	res.Body.Close()

	if g, e := res.StatusCode, 416; g != e {
		t.Errorf("got status = %d; want %d", g, e)
	}
	if g, e := string(out), "invalid range: failed to overlap\n"; g != e {
		t.Errorf("got body = %q; want %q", g, e)
	}

	SYS_GETPID                          = 0x19D // 413
	SYS_GETPPID                         = 0x19E // 414
	SYS_GETPWNAM                        = 0x19F // 415
	SYS_GETPWUID                        = 0x1A0 // 416
	SYS_GETUID                          = 0x1A1 // 417
	SYS_W_IOCTL                         = 0x1A2 // 418
	SYS_ISATTY                          = 0x1A3 // 419
	SYS_KILL                            = 0x1A4 // 420

   *     }
   * };
   * Multimap<String, String> transformed =
   *     Multimaps.transformValues(multimap, square);
   *   System.out.println(transformed);
   * }</pre>
   *
   * ... prints {@code {a=[4, 16], b=[9, 9], c=[36]}}.
   *
   * <p>Changes in the underlying multimap are reflected in this view. Conversely, this view
   * supports removal operations, and these are reflected in the underlying multimap.
   *

    assertCached(true, 410)
    assertCached(false, 411)
    assertCached(false, 412)
    assertCached(false, 413)
    assertCached(true, 414)
    assertCached(false, 415)
    assertCached(false, 416)
    assertCached(false, 417)
    assertCached(false, 418)
    assertCached(false, 500)
    assertCached(true, 501)
    assertCached(false, 502)
    assertCached(false, 503)
    assertCached(false, 504)

  %415 = "tf.Tile"(%244, %414) {device = ""} : (tensor<?x1xi64>, tensor<2xi32>) -> tensor<?x?xi64>
  %416 = "tf.Mul"(%413, %247) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %417 = "tf.Pack"(%416) {axis = 0 : i64, device = ""} : (tensor<i32>) -> tensor<1xi32>

		(Zero [s-s%16] ptr mem))
(Zero [s] ptr mem) && s%16 != 0 && s%16 > 8 && s > 16 =>
	(Zero [16]
		(OffPtr <ptr.Type> ptr [s-16])
		(Zero [s-s%16] ptr mem))

// medium zeroing uses a duff device
// 4, 16, and 64 are magic constants, see runtime/mkduff.go
(Zero [s] ptr mem)
	&& s%16 == 0 && s > 64 && s <= 16*64
	&& !config.noDuffDevice =>
	(DUFFZERO [4 * (64 - s/16)] ptr mem)

// large zeroing uses a loop

// -----

// CHECK-LABEL: @unpack
func.func @unpack(%input: tensor<4x3x6xf32>) -> (tensor<4x6xf32>, tensor<4x6xf32>, tensor<4x6xf32>) {
  // CHECK: %[[SLICE1:.*]] = "mhlo.slice"(%{{.*}}) <{limit_indices = dense<[4, 1, 6]> : tensor<3xi64>, start_indices = dense<0> : tensor<3xi64>, strides = dense<1> : tensor<3xi64>}> : (tensor<4x3x6xf32>) -> tensor<4x1x6xf32>
  // CHECK: %[[RES1:.*]] = mhlo.reshape %[[SLICE1]] : (tensor<4x1x6xf32>) -> tensor<4x6xf32>

		symEffect:      SymWrite,
		asm:            s390x.ASTMG,
		reg: regInfo{
			inputs: []inputInfo{
				{1, 2},     // R1
				{2, 4},     // R2
				{3, 8},     // R3
				{4, 16},    // R4
				{0, 56318}, // R1 R2 R3 R4 R5 R6 R7 R8 R9 R11 R12 R14 SP
			},
		},
	},
	{
		name:           "STM2",
		auxType:        auxSymOff,
		argLen:         4,