}

	if x64-v64_n*one64 > 0 {
		t.Errorf("'%#x - %#x*1 > 0' failed", x64, v64_n)
	}

	if x64-v64_n*one64 >= 0 {
		t.Errorf("'%#x - %#x*1 >= 0' failed", x64, v64_n)
	}

	if y64-v64*one64 < 0 {
		t.Errorf("'%#x - %#x*1 < 0' failed", y64, v64)
	}

	if y64-v64*one64 <= 0 {
		t.Errorf("'%#x - %#x*1 <= 0' failed", y64, v64)
	}

	if x64-x64b*one64 < 0 {

	cmpOpTest(t, "<", lt64_ssa, ltbr64_ssa, lt32_ssa, ltbr32_ssa, zero64, one64, inf64, nan64, 0x01100)
	cmpOpTest(t, ">", gt64_ssa, gtbr64_ssa, gt32_ssa, gtbr32_ssa, zero64, one64, inf64, nan64, 0x00000)
	cmpOpTest(t, ">=", ge64_ssa, gebr64_ssa, ge32_ssa, gebr32_ssa, zero64, one64, inf64, nan64, 0x10000)

	{
		lt, le, eq, ne, ge, gt := compares64_ssa(0.0, 1.0, inf64, nan64)

	one16      uint16 = 1
	thousand16 uint16 = 1000

	zero32     uint32 = 0
	zero32I    T32    = 0
	one32      uint32 = 1
	thousand32 uint32 = 1000

	zero64     uint64 = 0
	zero64I    T64    = 0
	one64      uint64 = 1
	thousand64 uint64 = 1000

	zerostr  string = ""
	zerostrI Tstr   = ""
	nzstr    string = "abc"

	zeroslice  []byte = nil
	zerosliceI Tslice = nil
	nzslice    []byte = []byte("abc")

	}
}

var (
	one64  int64  = 1
	one64u uint64 = 1
	one32  int32  = 1
	one32u uint32 = 1
	one16  int16  = 1
	one16u uint16 = 1
	one8   int8   = 1
	one8u  uint8  = 1
)

func TestShiftLargeCombine(t *testing.T) {
	var N uint64 = 0x8000000000000000
	if one64<<N<<N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one64>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")

      Inputs(
          Out(NodeWith(Op("Slice"), AssignedDevice(kHostName),
                       Inputs(m_input_shape, Const(zero_64), Const(one_64)))),
          Out(NodeWith(Op("Slice"), AssignedDevice(kHostName),
                       Inputs(m_begin_s64, Const(zero_64), Const(one_64)))))));
  auto m_dynamic_slice_size =
      Out(NodeWith(Op("ConcatV2"), AssignedDevice(kHostName),