}
	}

	// Compute fast range-minimum query data structure
	rangeMin := make([][]ID, 0, bits.Len64(uint64(len(tour))))
	rangeMin = append(rangeMin, tour) // 1-size windows are just the tour itself.
	for logS, s := 1, 2; s < len(tour); logS, s = logS+1, s*2 {
		r := make([]ID, len(tour)-s+1)
		for i := 0; i < len(tour)-s+1; i++ {
			bid := rangeMin[logS-1][i]
			bid2 := rangeMin[logS-1][i+s/2]
			if blocks[bid2].depth < blocks[bid].depth {

// license that can be found in the LICENSE file.

// Torture test for range-over-func.
//
// cmd/internal/testdir runs this like
//
//	go run rangegen.go >x.go
//	go run x.go
//
// but a longer version can be run using
//
//	go run rangegen.go long
//
// In that second form, rangegen takes care of compiling
// and running the code it generates, in batches.
// That form takes 10-20 minutes to run.

package main

import (

Robert Griesemer <******@****.***> 1713826379 -0700

		}

		if !isSet {
			w.Header().Set(k, v)
		}
	}

	var start, rangeLen int64
	totalObjectSize, err := objInfo.GetActualSize()
	if err != nil {
		return err
	}

	if rs == nil && opts.PartNumber > 0 {
		rs = partNumberToRangeSpec(objInfo, opts.PartNumber)
	}

	// For providing ranged content
	start, rangeLen, err = rs.GetOffsetLength(totalObjectSize)
	if err != nil {
		return err
	}

    int32 quantize_axis = 2;
    // The minimum allowed value of the fixed-point data range.
    // This can also be used to derive the sign of storage type.
    int32 range_min = 3;
    // The minimum allowed value of the fixed-point data range.
    int32 range_max = 4;
  }

  // The quantization parameters for a named tensor.
  message QuantParams {

   (TF_SelectV2Op:$num_upper_or_n (TF_LessOp $num_upper, $zero),
                                  $n, $num_upper),
   (TF_RangeOp:$range_m $zero, $m, $one),
   (TF_RangeOp:$range_n $zero, $n, $one),
   (TF_SubOp:$offset (TF_ExpandDimsOp $range_m, $neg_one), $range_n),
   (TF_LogicalAndOp:$indicator (TF_LessEqualOp $offset, $num_lower_or_m),
                               (TF_GreaterEqualOp $offset,

						// For providing ranged content
						start, rangeLen, err := rs.GetOffsetLength(ci.Size)
						if err != nil {
							start, rangeLen = 0, ci.Size
						}

						// Set content length.
						w.Header().Set(xhttp.ContentLength, strconv.FormatInt(rangeLen, 10))
						if rs != nil {
							contentRange := fmt.Sprintf("bytes %d-%d/%d", start, start+rangeLen-1, ci.Size)
							w.Header().Set(xhttp.ContentRange, contentRange)

    }, {
      "tf.Yield"(%arg1) : (tensor<f32>) -> ()
    }) { is_stateless = true}: (tensor<i1>) -> tensor<f32>
  func.return %0 : tensor<f32>
}

// CHECK-LABEL: @range_int
func.func @range_int() -> tensor<?xi32> {
  %cst = arith.constant dense<0> : tensor<i32>
  %cst_1 = arith.constant dense<4> : tensor<i32>
  %cst_2 = arith.constant dense<1> : tensor<i32>

  // CHECK: return %[[CST]]
  %0 = "tfl.pseudo_const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
  func.return %0 : tensor<i32>
}


// CHECK-LABEL: @range_int
func.func @range_int() -> tensor<?xi32> {
  %cst = arith.constant dense<0> : tensor<i32>
  %cst_1 = arith.constant dense<4> : tensor<i32>
  %cst_2 = arith.constant dense<1> : tensor<i32>

  // CHECK-DAG: %[[RANGE_N:.*]] = "tf.Range"(%[[ZERO]], %[[N]], %[[ONE]]) : (tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<?xi32>
  // CHECK-DAG: %[[EXPAND_DIMS:.*]] = "tf.ExpandDims"(%[[RANGE_M]], %[[NEG_ONE]]) : (tensor<?xi32>, tensor<i32>) -> tensor<?x1xi32>
  // CHECK-DAG: %[[OFFSET:.*]] = "tf.Sub"(%[[EXPAND_DIMS]], %[[RANGE_N]]) : (tensor<?x1xi32>, tensor<?xi32>) -> tensor<?x?xi32>