auto canonicalize = [&](int64_t point, int c) {
      if (masks[c]) return stride_i > 0 ? bounds[c] : bounds[(c + 1) & 1];

      // Add dim as offset to negative range point.
      point = point < 0 ? dim_i + point : point;
      return Clamp(point, bounds[0], bounds[1]);
    };

    begin_i = canonicalize(begin_i, 0);
    end_i = canonicalize(end_i, 1);

		n := int((*arrayType)(unsafe.Pointer(v.typ())).Len)
		return unsafe.Slice(p, n)
	}
	panic(&ValueError{"reflect.Value.Bytes", v.kind()})
}

// runes returns v's underlying value.
// It panics if v's underlying value is not a slice of runes (int32s).
func (v Value) runes() []rune {
	v.mustBe(Slice)
	if v.typ().Elem().Kind() != abi.Int32 {
		panic("reflect.Value.Bytes of non-rune slice")
	}

	}

	// Remove m from allm.
	lock(&sched.lock)
	for pprev := &allm; *pprev != nil; pprev = &(*pprev).alllink {
		if *pprev == mp {
			*pprev = mp.alllink
			goto found
		}
	}
	throw("m not found in allm")
found:
	// Events must not be traced after this point.

	// Delay reaping m until it's done with the stack.
	//
	// Put mp on the free list, though it will not be reaped while freeWait

      "dev": true
    },
    "node_modules/binary-search-bounds": {
      "version": "2.0.5",
      "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.5.tgz",
      "integrity": "sha512-H0ea4Fd3lS1+sTEB2TgcLoK21lLhwEJzlQv3IN47pJS976Gx4zoWe0ak3q+uYh60ppQxg9F16Ri4tS1sfD4+jA=="
    },

    return op.emitOpError()
           << "found invalid output dimension on row, expected "
           << expected_out_row_dim << " but got " << out_row_dim;
  if (expected_out_col_dim != ShapedType::kDynamic &&
      out_col_dim != ShapedType::kDynamic &&
      out_col_dim != expected_out_col_dim)
    return op.emitOpError()
           << "found invalid output dimension on col, expected "

(Leq32 _ (Const32 [math.MaxInt32]))  => (ConstBool [true])
(Leq16 _ (Const16 [math.MaxInt16]))  => (ConstBool [true])
(Leq8  _ (Const8  [math.MaxInt8 ]))  => (ConstBool [true])

// Canonicalize <= on numeric bounds and < near numeric bounds to ==
(Leq(64|32|16|8)U x c:(Const(64|32|16|8) [0]))     => (Eq(64|32|16|8) x c)
(Leq(64|32|16|8)U c:(Const(64|32|16|8) [-1]) x)    => (Eq(64|32|16|8) x c)

}

func.func @round(%arg0: tensor<8x16xf32>) -> tensor<8x16xf32> {
  %0 = "tf.Round"(%arg0) : (tensor<8x16xf32>) -> tensor<8x16xf32>
  func.return %0 : tensor<8x16xf32>

  // CHECK-LABEL: round
  // CHECK: %[[ARG:.*]]: tensor<8x16xf32>
  // CHECK: %[[RESULT:.*]] = "tfl.round"(%[[ARG]]) : (tensor<8x16xf32>) -> tensor<8x16xf32>

				found := false
				for _, warning := range recorder.Warnings() {
					if warning == expectedWarning {
						found = true
						break
					}
				}
				assert.True(t, found, "expected warning %q not found", expectedWarning)
			}

		})
	}
}

// Runs transition rule cases with OptionalOldSelf set to true on the schema
func TestOptionalOldSelf(t *testing.T) {

    public static final String ERRORS_failed_to_delete_file = "{errors.failed_to_delete_file}";

    /** The key of the message: Not found Doc ID:{0} */
    public static final String ERRORS_docid_not_found = "{errors.docid_not_found}";

    /** The key of the message: Not found URL of Doc ID:{0} */
    public static final String ERRORS_document_not_found = "{errors.document_not_found}";

        val type: KaClassLikeSymbol
        val bounds: List<KaType>
    }

    interface InconsistentTypeParameterBounds : KaFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = InconsistentTypeParameterBounds::class
        val typeParameter: KaTypeParameterSymbol
        val type: KaClassLikeSymbol
        val bounds: List<KaType>
    }