// Nil renders the nil identifier.
975443
func (g *Group) Nil() *Statement {
	// notest
	s := Nil()
	g.items = append(g.items, s)
	return s
}
841598
func (t *File_Template) RenderL(m LiteralMap) (string, error) {
	pm, err := m.Convert()
	if err != nil {
		return "", err
	}
	return t.Render(pm)
}
437993
func (t *Table) renderTerminal() string {
	// Use a placeholder rather than adding titles/headers to the tables
	// elements or else successive calls will compound them.
	tt := t.clone()

	// Initial top line.
	if !tt.Style.SkipBorder {
		if tt.title != nil && tt.headers == nil {
			tt.elements = append([]Element{&Separator{where: LINE_SUBTOP}}, tt.elements...)
		} else if tt.title == nil && tt.headers == nil {
			tt.elements = append([]Element{&Separator{where: LINE_TOP}}, tt.elements...)
		} else {
			tt.elements = append([]Element{&Separator{where: LINE_INNER}}, tt.elements...)
		}
	}

	// If we have headers, include them.
	if tt.headers != nil {
		ne := make([]Element, 2)
		ne[1] = CreateRow(tt.headers)
		if tt.title != nil {
			ne[0] = &Separator{where: LINE_SUBTOP}
		} else {
			ne[0] = &Separator{where: LINE_TOP}
		}
		tt.elements = append(ne, tt.elements...)
	}

	// If we have a title, write it.
	if tt.title != nil {
		// Match changes to this into renderMarkdown too.
		tt.titleCell = CreateCell(tt.title, &CellStyle{Alignment: AlignCenter, ColSpan: 999})
		ne := []Element{
			&StraightSeparator{where: LINE_TOP},
			CreateRow([]interface{}{tt.titleCell}),
		}
		tt.elements = append(ne, tt.elements...)
	}

	// Create a new table from the
	// generate the runtime style. Must include all cells being printed.
	style := createRenderStyle(tt)

	// Loop over the elements and render them.
	b := bytes.NewBuffer(nil)
	for _, e := range tt.elements {
		b.WriteString(e.Render(style))
		b.WriteString("\n")
	}

	// Add bottom line.
	if !style.SkipBorder {
		b.WriteString((&Separator{where: LINE_BOTTOM}).Render(style) + "\n")
	}

	return b.String()
}
1088487
func Errorln(v ...interface{}) {
	std.Fprint(std.flags, LEVEL_ERROR, 2, fmt.Sprintln(v...), nil)
}
385193
func (r *Store) URL() string {
	if r.url == nil {
		return ""
	}
	return r.url.String()
}
1198102
func (primative *Primative) AsNull() (interface{}, error) {
	switch val := primative.value.(type) {
	case nil:
		return val, nil
	}

	msg := fmt.Sprintf("Could not convert value %s to nil", primative.value)
	return 0, errors.New(msg)
}
872589
func (o *Organizer) NIt(name string, f func()) {
	o.tests = append(o.tests, test{name, nil})
}
675293
func (f *Fn) Syscall() string {
	c := f.SyscallParamCount()
	if c == 3 {
		return syscalldot() + "Syscall"
	}
	return syscalldot() + "Syscall" + strconv.Itoa(c)
}
255766
func (s *IndexService) Ttl(ttl string) *IndexService {
	s.ttl = ttl
	return s
}
284012
func Siphash(in []byte, k []byte, cr, dr int, dbl bool) (ra, rb uint64) {
	var fast = true
	var v0, v1, v2, v3 uint64
	var sipround = func() {
		v0 += v1; v1=rotl(v1,13); v1 ^= v0; v0=rotl(v0,32);
		v2 += v3; v3=rotl(v3,16); v3 ^= v2;
		v0 += v3; v3=rotl(v3,21); v3 ^= v0;
		v2 += v1; v1=rotl(v1,17); v1 ^= v2; v2=rotl(v2,32);
	}

	if len(k) != 16 || cr <= 0 || dr <= 0 {
		panic("siphash")
	}
	// initialize state
	/* "somepseudorandomlygeneratedbytes" */
	v0 = uint64(0x736f6d6570736575)
	v1 = uint64(0x646f72616e646f6d)
	v2 = uint64(0x6c7967656e657261)
	v3 = uint64(0x7465646279746573)

	k0 := U8tou64le(k)
	k1 := U8tou64le(k[8:])
	b := uint64(len(in)) << 56
	//fmt.Printf("k=%v, k0=0x%08x, k1=0x%08x, b=0x%08x\n", k, k0, k1, b)

	v3 ^= k1
	v2 ^= k0
	v1 ^= k1
	v0 ^= k0

	if dbl {
		v1 ^= 0xee
	}

	k64 := sliceUI64(in)
	cnt := 0
	l := len(in)
	// peel off as many 64 bit words as we have
	if fast {
		for ; l >= 8; in = in[8:] {
	    	m := k64[cnt]
	    	cnt++
	    	l -= 8
	    	v3 ^= m

			//TRACE(len(in), v0, v1, v2, v3)
	    	for i := 0; i < cr; i++ {
	    		sipround()
	    		//v0, v1, v2, v3 = siprounda(v0, v1, v2, v3)
	    		//v0, v1, v2, v3 = siproundb(v0, v1, v2, v3)
			}
			v0 ^= m
		}
	} else {
		for ; len(in) >= 8; in = in[8:] {
	    	m := U8tou64le(in)
	    	v3 ^= m

			//TRACE(len(in), v0, v1, v2, v3)
	    	for i := 0; i < cr; i++ {
	    		sipround()
	    		//v0, v1, v2, v3 = siprounda(v0, v1, v2, v3)
	    		//v0, v1, v2, v3 = siproundb(v0, v1, v2, v3)
			}
			v0 ^= m
		}
	}

	//fmt.Printf("in=%v, len(in)=%d\n", in, len(in))
	// deal with the tail
	switch len(in) {
	case 7:
		b |= uint64(in[6]) << 48
		fallthrough
	case 6:
		b |= uint64(in[5]) << 40
		fallthrough
	case 5:
		b |= uint64(in[4]) << 32
		fallthrough
	case 4:
		b |= uint64(in[3]) << 24
		fallthrough
	case 3:
		b |= uint64(in[2]) << 16
		fallthrough
	case 2:
		b |= uint64(in[1]) <<  8
		fallthrough
	case 1:
		b |= uint64(in[0])
		break;
	case 0:
		break;
	default:
		//fmt.Printf("len(in)=%d\n", len(in))
		panic("siphash bad length")
	}
	v3 ^= b;

	//TRACE(len(in), v0, v1, v2, v3)
	for i := 0; i < cr; i++ {
		sipround()
		//v0, v1, v2, v3 = siprounda(v0, v1, v2, v3)
		//v0, v1, v2, v3 = siproundb(v0, v1, v2, v3)
	}
	v0 ^= b

	if dbl {
		v2 ^= 0xee
	} else {
		v2 ^= 0xff
	}

	//TRACE(len(in), v0, v1, v2, v3)
	for i := 0; i < dr; i++ {
		sipround()
		//v0, v1, v2, v3 = siprounda(v0, v1, v2, v3)
		//v0, v1, v2, v3 = siproundb(v0, v1, v2, v3)
	}
	b = v0 ^ v1 ^ v2  ^ v3
	ra = b

	// if 128 bit result desired run some more rounds and get another 64 bits
	if dbl {
  		v1 ^= 0xdd
		//TRACE(len(in), v0, v1, v2, v3)
		for i := 0; i < dr; i++ {
			sipround()
    		//v0, v1, v2, v3 = siprounda(v0, v1, v2, v3)
    		//v0, v1, v2, v3 = siproundb(v0, v1, v2, v3)
		}
		b = v0 ^ v1 ^ v2  ^ v3
		rb = b
	}
	return
}
909069
func (me *DefaultAdapter) LiteralNil(buf *SqlBuilder) error {
	buf.Write(me.Null)
	return nil
}
354889
func anyNil(objs ...interface{}) bool {
	for _, p := range objs {
		if p == nil {
			return true
		}
	}
	return false
}
410610
func NotNil(t testing.TB, expr interface{}, args ...interface{}) {
	assert(t, !IsNil(expr), args, []interface{}{"NotNil 失败，实际值为[%T:%[1]v]", expr})
}
155285
func renderTpl(writer io.Writer, name string, data interface{}) error {
	if tpl == nil {
		return errors.New("Rendering template error! Please compile your templates.")
	}

	return tpl.ExecuteTemplate(writer, name, data)
}
494477
func Itol(level int) Level {
	switch level {
	case 0:
		return DEBUG
	case 1:
		return INFO
	case 2:
		return WARN
	case 3:
		return ERROR
	case 4:
		return FATAL
	default:
		return DEBUG
	}
}
501588
func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) {
	var (
		ret0 = new(uint64)
	)
	out := ret0
	err := _ENS.contract.Call(opts, out, "ttl", node)
	return *ret0, err
}
301717
func Nin(col I, values ...interface{}) Condition {
	return Condition{
		Type:  ConditionNin,
		Left:  NewOperand(col),
		Right: NewOperand(values...),
	}
}