diff --git a/cue/ast_test.go b/cue/ast_test.go
index 4fe6367..1f6ae18 100644
--- a/cue/ast_test.go
+++ b/cue/ast_test.go
@@ -19,6 +19,8 @@
 	"testing"
 
 	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/parser"
+	"cuelang.org/go/cue/token"
 )
 
 func TestCompile(t *testing.T) {
@@ -287,3 +289,70 @@
 		})
 	}
 }
+
+func TestEval(t *testing.T) {
+	testCases := []struct {
+		in   string
+		expr string
+		out  string
+	}{{
+		in: `
+			hello: "Hello"
+			world: "World"
+			`,
+		expr: `"\(hello), \(world)!"`,
+		out:  `"Hello, World!"`,
+	}, {
+		in: `
+			a: { b: 2, c: 3 }
+			z: 1
+			`,
+		expr: `a.b + a.c + z`,
+		out:  `6`,
+	}, {
+		in: `
+			a: { b: 2, c: 3 }
+			`,
+		expr: `{ d: a.b + a.c }`,
+		out:  `<0>{d: 5}`,
+	}, {
+		in: `
+			a: "Hello World!"
+			`,
+		expr: `strings.ToUpper(a)`,
+		out:  `"HELLO WORLD!"`,
+	}, {
+		in: `
+			a: 0x8
+			b: 0x1`,
+		expr: `bits.Or(a, b)`, // package shorthand
+		out:  `9`,
+	}, {
+		in: `
+			a: 0x8
+			b: 0x1`,
+		expr: `math.Or(a, b)`,
+		out:  `_|_(<0>.Or:undefined field "Or")`,
+	}, {
+		in:   `a: 0x8`,
+		expr: `mathematics.Abs(a)`,
+		out:  `_|_(reference "mathematics" not found)`,
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			ctx, inst, errs := compileInstance(t, tc.in)
+			if errs != nil {
+				t.Fatal(errs)
+			}
+			expr, err := parser.ParseExpr(token.NewFileSet(), "<test>", tc.expr)
+			if err != nil {
+				t.Fatal(err)
+			}
+			evaluated := inst.evalExpr(ctx, expr)
+			v := testResolve(ctx, evaluated, evalFull)
+			if got := debugStr(ctx, v); got != tc.out {
+				t.Errorf("output differs:\ngot  %q\nwant %q", got, tc.out)
+			}
+		})
+	}
+}
diff --git a/cue/builtin.go b/cue/builtin.go
index 3aab148..daaaae0 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:generate go run gen.go
+
 package cue
 
 import (
diff --git a/cue/builtin_test.go b/cue/builtin_test.go
index 9befd60..c35c9bb 100644
--- a/cue/builtin_test.go
+++ b/cue/builtin_test.go
@@ -15,8 +15,10 @@
 package cue
 
 import (
+	"fmt"
 	"math/big"
 	"reflect"
+	"strings"
 	"testing"
 
 	"cuelang.org/go/cue/ast"
@@ -125,3 +127,111 @@
 		})
 	}
 }
+
+func TestBuiltins(t *testing.T) {
+	test := func(pkg, expr string) []*bimport {
+		return []*bimport{&bimport{"",
+			[]string{fmt.Sprintf("import %q\n(%s)", pkg, expr)},
+		}}
+	}
+	testExpr := func(expr string) []*bimport {
+		return []*bimport{&bimport{"",
+			[]string{fmt.Sprintf("(%s)", expr)},
+		}}
+	}
+	testCases := []struct {
+		instances []*bimport
+		emit      string
+	}{{
+		test("math", "math.Pi"),
+		`3.14159265358979323846264338327950288419716939937510582097494459`,
+	}, {
+		test("math", "math.Floor(math.Pi)"),
+		`3`,
+	}, {
+		test("math", "math.Pi(3)"),
+		`_|_(<0>.Pi:cannot call non-function 3.14159265358979323846264338327950288419716939937510582097494459 (type float))`,
+	}, {
+		test("math", "math.Floor(3, 5)"),
+		`_|_(<0>.Floor (3,5):number of arguments does not match (1 vs 2))`,
+	}, {
+		test("math", `math.Floor("foo")`),
+		`_|_(<0>.Floor ("foo"):argument 1 requires type number, found string)`,
+	}, {
+		test("encoding/hex", `hex.Encode("foo")`),
+		`"666f6f"`,
+	}, {
+		test("encoding/hex", `hex.Decode(hex.Encode("foo"))`),
+		`'foo'`,
+	}, {
+		test("encoding/hex", `hex.Decode("foo")`),
+		`_|_(<0>.Decode ("foo"):call error: encoding/hex: invalid byte: U+006F 'o')`,
+	}, {
+		test("strconv", `strconv.FormatUint(64, 16)`),
+		`"40"`,
+	}, {
+		// Find a better alternative, as this call should go.
+		test("strconv", `strconv.FormatFloat(3.02, 300, 4, 64)`),
+		`_|_(<0>.FormatFloat (3.02,300,4,64):argument 1 out of range: has 9 > 8 bits)`,
+	}, {
+		// Find a better alternative, as this call should go.
+		test("strconv", `strconv.FormatFloat(3.02, -1, 4, 64)`),
+		`_|_(<0>.FormatFloat (3.02,-1,4,64):argument 1 must be a positive integer)`,
+	}, {
+		// Find a better alternative, as this call should go.
+		test("strconv", `strconv.FormatFloat(3.02, 1.0, 4, 64)`),
+		`_|_(<0>.FormatFloat (3.02,1.0,4,64):argument 2 requires type int, found float)`,
+	}, {
+		// Panics
+		test("math", `math.Jacobi(1000, 2000)`),
+		`_|_(<0>.Jacobi (1000,2000):call error: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000)`,
+	}, {
+		test("math", `math.Jacobi(1000, 201)`),
+		`1`,
+	}, {
+		test("math", `math.Asin(2.0e400)`),
+		`_|_(<0>.Asin (2.0e+400):invalid argument 0: cue: value was rounded up)`,
+	}, {
+		test("encoding/csv", `csv.Decode("1,2,3\n4,5,6")`),
+		`[["1","2","3"],["4","5","6"]]`,
+	}, {
+		test("strconv", `strconv.FormatBool(true)`),
+		`"true"`,
+	}, {
+		test("strings", `strings.Join(["Hello", "World!"], " ")`),
+		`"Hello World!"`,
+	}, {
+		test("strings", `strings.Join([1, 2], " ")`),
+		`_|_(<0>.Join ([1,2]," "):list element 1: not of right kind (number vs string))`,
+	}, {
+		test("math/bits", `bits.Or(0x8, 0x1)`),
+		`9`,
+	}, {
+		testExpr(`len({})`),
+		`0`,
+	}, {
+		testExpr(`len({a: 1, b: 2, <foo>: int, _c: 3})`),
+		`2`,
+	}, {
+		testExpr(`len([1, 2, 3])`),
+		`3`,
+	}, {
+		testExpr(`len("foo")`),
+		`3`,
+	}, {
+		testExpr(`len('f\x20\x20')`),
+		`3`,
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			insts := Build(makeInstances(tc.instances))
+			if err := insts[0].Err; err != nil {
+				t.Fatal(err)
+			}
+			got := strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+			if got != tc.emit {
+				t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
+			}
+		})
+	}
+}
diff --git a/cue/builtins.go b/cue/builtins.go
new file mode 100644
index 0000000..b7c920f
--- /dev/null
+++ b/cue/builtins.go
@@ -0,0 +1,1841 @@
+// Code generated by go generate. DO NOT EDIT.
+
+package cue
+
+import (
+	"bytes"
+	"crypto/md5"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"cuelang.org/go/cue/parser"
+	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal/third_party/yaml"
+	"encoding/csv"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	goyaml "github.com/ghodss/yaml"
+	"html"
+	"io"
+	"math"
+	"math/big"
+	"math/bits"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+	"text/template"
+	"unicode"
+)
+
+func init() {
+	initBuiltins(builtinPackages)
+}
+
+var _ io.Reader
+
+var split = path.Split
+
+var pathClean = path.Clean
+
+var pathExt = path.Ext
+
+var pathBase = path.Base
+
+var pathIsAbs = path.IsAbs
+
+var pathDir = path.Dir
+
+var builtinPackages = map[string][]*builtin{
+	"": []*builtin{{}},
+	"crypto/md5": []*builtin{{
+		Name:  "Size",
+		Const: intFromGo("16"),
+	}, {
+		Name:  "BlockSize",
+		Const: intFromGo("64"),
+	}, {
+		Name:   "Sum",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return md5.Sum(data)
+			}()
+		},
+	}},
+	"crypto/sha1": []*builtin{{
+		Name:  "Size",
+		Const: intFromGo("20"),
+	}, {
+		Name:  "BlockSize",
+		Const: intFromGo("64"),
+	}, {
+		Name:   "Sum",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha1.Sum(data)
+			}()
+		},
+	}},
+	"crypto/sha256": []*builtin{{
+		Name:  "Size",
+		Const: intFromGo("32"),
+	}, {
+		Name:  "Size224",
+		Const: intFromGo("28"),
+	}, {
+		Name:  "BlockSize",
+		Const: intFromGo("64"),
+	}, {
+		Name:   "Sum256",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha256.Sum256(data)
+			}()
+		},
+	}, {
+		Name:   "Sum224",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha256.Sum224(data)
+			}()
+		},
+	}},
+	"crypto/sha512": []*builtin{{
+		Name:  "Size",
+		Const: intFromGo("64"),
+	}, {
+		Name:  "Size224",
+		Const: intFromGo("28"),
+	}, {
+		Name:  "Size256",
+		Const: intFromGo("32"),
+	}, {
+		Name:  "Size384",
+		Const: intFromGo("48"),
+	}, {
+		Name:  "BlockSize",
+		Const: intFromGo("128"),
+	}, {
+		Name:   "Sum512",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha512.Sum512(data)
+			}()
+		},
+	}, {
+		Name:   "Sum384",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha512.Sum384(data)
+			}()
+		},
+	}, {
+		Name:   "Sum512_224",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha512.Sum512_224(data)
+			}()
+		},
+	}, {
+		Name:   "Sum512_256",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return sha512.Sum512_256(data)
+			}()
+		},
+	}},
+	"encoding/csv": []*builtin{{
+		Name:   "Encode",
+		Params: []kind{topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			x := c.value(0)
+			c.ret, c.err = func() (interface{}, error) {
+				buf := &bytes.Buffer{}
+				w := csv.NewWriter(buf)
+				iter, err := x.List()
+				if err != nil {
+					return "", err
+				}
+				for iter.Next() {
+					row, err := iter.Value().List()
+					if err != nil {
+						return "", err
+					}
+					a := []string{}
+					for row.Next() {
+						col := row.Value()
+						if str, err := col.String(); err == nil {
+							a = append(a, str)
+						} else {
+							b, err := col.MarshalJSON()
+							if err != nil {
+								return "", err
+							}
+							a = append(a, string(b))
+						}
+					}
+					w.Write(a)
+				}
+				w.Flush()
+				return buf.String(), nil
+			}()
+		},
+	}, {
+		Name:   "Decode",
+		Params: []kind{stringKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			r := c.reader(0)
+			c.ret, c.err = func() (interface{}, error) {
+				return csv.NewReader(r).ReadAll()
+			}()
+		},
+	}},
+	"encoding/hex": []*builtin{{
+		Name:   "EncodedLen",
+		Params: []kind{intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			n := c.int(0)
+			c.ret = func() interface{} {
+				return hex.EncodedLen(n)
+			}()
+		},
+	}, {
+		Name:   "DecodedLen",
+		Params: []kind{intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x := c.int(0)
+			c.ret = func() interface{} {
+				return hex.DecodedLen(x)
+			}()
+		},
+	}, {
+		Name:   "Decode",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret, c.err = func() (interface{}, error) {
+				return hex.DecodeString(s)
+			}()
+		},
+	}, {
+		Name:   "Dump",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return hex.Dump(data)
+			}()
+		},
+	}, {
+		Name:   "Encode",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			src := c.bytes(0)
+			c.ret = func() interface{} {
+				return hex.EncodeToString(src)
+			}()
+		},
+	}},
+	"encoding/json": []*builtin{{
+		Name:   "Valid",
+		Params: []kind{stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret = func() interface{} {
+				return json.Valid(data)
+			}()
+		},
+	}, {
+		Name:   "Compact",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			src := c.bytes(0)
+			c.ret, c.err = func() (interface{}, error) {
+				dst := bytes.Buffer{}
+				if err := json.Compact(&dst, src); err != nil {
+					return "", err
+				}
+				return dst.String(), nil
+			}()
+		},
+	}, {
+		Name:   "Indent",
+		Params: []kind{stringKind, stringKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			src, prefix, indent := c.bytes(0), c.string(1), c.string(2)
+			c.ret, c.err = func() (interface{}, error) {
+				dst := bytes.Buffer{}
+				if err := json.Indent(&dst, src, prefix, indent); err != nil {
+					return "", err
+				}
+				return dst.String(), nil
+			}()
+		},
+	}, {
+		Name:   "HTMLEscape",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			src := c.bytes(0)
+			c.ret = func() interface{} {
+				dst := &bytes.Buffer{}
+				json.HTMLEscape(dst, src)
+				return dst.String()
+			}()
+		},
+	}, {
+		Name:   "Marshal",
+		Params: []kind{topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			v := c.value(0)
+			c.ret, c.err = func() (interface{}, error) {
+				b, err := json.Marshal(v)
+				return string(b), err
+			}()
+		},
+	}, {
+		Name:   "MarshalStream",
+		Params: []kind{topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			v := c.value(0)
+			c.ret, c.err = func() (interface{}, error) {
+
+				iter, err := v.List()
+				if err != nil {
+					return "", err
+				}
+				buf := &bytes.Buffer{}
+				for iter.Next() {
+					b, err := json.Marshal(iter.Value())
+					if err != nil {
+						return "", err
+					}
+					buf.Write(b)
+					buf.WriteByte('\n')
+				}
+				return buf.String(), nil
+			}()
+		},
+	}, {
+		Name:   "Unmarshal",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			b := c.bytes(0)
+			c.ret, c.err = func() (interface{}, error) {
+				if !json.Valid(b) {
+					return nil, fmt.Errorf("json: invalid JSON")
+				}
+				fset := token.NewFileSet()
+				expr, err := parser.ParseExpr(fset, "json", b)
+				if err != nil {
+
+					return nil, fmt.Errorf("json: could not parse JSON: %v", err)
+				}
+				return FromExpr(fset, expr)
+			}()
+		},
+	}},
+	"encoding/yaml": []*builtin{{
+		Name:   "Marshal",
+		Params: []kind{topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			v := c.value(0)
+			c.ret, c.err = func() (interface{}, error) {
+				b, err := goyaml.Marshal(v)
+				return string(b), err
+			}()
+		},
+	}, {
+		Name:   "MarshalStream",
+		Params: []kind{topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			v := c.value(0)
+			c.ret, c.err = func() (interface{}, error) {
+
+				iter, err := v.List()
+				if err != nil {
+					return "", err
+				}
+				buf := &bytes.Buffer{}
+				for i := 0; iter.Next(); i++ {
+					if i > 0 {
+						buf.WriteString("---\n")
+					}
+					b, err := goyaml.Marshal(iter.Value())
+					if err != nil {
+						return "", err
+					}
+					buf.Write(b)
+				}
+				return buf.String(), nil
+			}()
+		},
+	}, {
+		Name:   "Unmarshal",
+		Params: []kind{stringKind},
+		Result: topKind,
+		Func: func(c *callCtxt) {
+			data := c.bytes(0)
+			c.ret, c.err = func() (interface{}, error) {
+				fset := token.NewFileSet()
+				expr, err := yaml.Unmarshal(fset, "", data)
+				if err != nil {
+					return nil, err
+				}
+				return FromExpr(fset, expr)
+			}()
+		},
+	}},
+	"html": []*builtin{{
+		Name:   "Escape",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return html.EscapeString(s)
+			}()
+		},
+	}, {
+		Name:   "Unescape",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return html.UnescapeString(s)
+			}()
+		},
+	}},
+	"list": []*builtin{{}},
+	"math": []*builtin{{
+		Name:  "MaxExp",
+		Const: intFromGo("2147483647"),
+	}, {
+		Name:  "MinExp",
+		Const: intFromGo("-2147483648"),
+	}, {
+		Name:  "MaxPrec",
+		Const: intFromGo("4294967295"),
+	}, {
+		Name:  "ToNearestEven",
+		Const: intFromGo("0"),
+	}, {
+		Name:  "ToNearestAway",
+		Const: intFromGo("1"),
+	}, {
+		Name:  "ToZero",
+		Const: intFromGo("2"),
+	}, {
+		Name:  "AwayFromZero",
+		Const: intFromGo("3"),
+	}, {
+		Name:  "ToNegativeInf",
+		Const: intFromGo("4"),
+	}, {
+		Name:  "ToPositiveInf",
+		Const: intFromGo("5"),
+	}, {
+		Name:  "Below",
+		Const: intFromGo("-1"),
+	}, {
+		Name:  "Exact",
+		Const: intFromGo("0"),
+	}, {
+		Name:  "Above",
+		Const: intFromGo("1"),
+	}, {
+		Name:   "Jacobi",
+		Params: []kind{intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x, y := c.bigInt(0), c.bigInt(1)
+			c.ret = func() interface{} {
+				return big.Jacobi(x, y)
+			}()
+		},
+	}, {
+		Name:  "MaxBase",
+		Const: intFromGo("62"),
+	}, {
+		Name:   "Floor",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Floor(x)
+			}()
+		},
+	}, {
+		Name:   "Ceil",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Ceil(x)
+			}()
+		},
+	}, {
+		Name:   "Trunc",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Trunc(x)
+			}()
+		},
+	}, {
+		Name:   "Round",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Round(x)
+			}()
+		},
+	}, {
+		Name:   "RoundToEven",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.RoundToEven(x)
+			}()
+		},
+	}, {
+		Name:   "Abs",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Abs(x)
+			}()
+		},
+	}, {
+		Name:   "Acosh",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Acosh(x)
+			}()
+		},
+	}, {
+		Name:   "Asin",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Asin(x)
+			}()
+		},
+	}, {
+		Name:   "Acos",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Acos(x)
+			}()
+		},
+	}, {
+		Name:   "Asinh",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Asinh(x)
+			}()
+		},
+	}, {
+		Name:   "Atan",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Atan(x)
+			}()
+		},
+	}, {
+		Name:   "Atan2",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			y, x := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Atan2(y, x)
+			}()
+		},
+	}, {
+		Name:   "Atanh",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Atanh(x)
+			}()
+		},
+	}, {
+		Name:   "Cbrt",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Cbrt(x)
+			}()
+		},
+	}, {
+		Name:  "E",
+		Const: floatFromGo("2.71828182845904523536028747135266249775724709369995957496696763"),
+	}, {
+		Name:  "Pi",
+		Const: floatFromGo("3.14159265358979323846264338327950288419716939937510582097494459"),
+	}, {
+		Name:  "Phi",
+		Const: floatFromGo("1.61803398874989484820458683436563811772030917980576286213544861"),
+	}, {
+		Name:  "Sqrt2",
+		Const: floatFromGo("1.41421356237309504880168872420969807856967187537694807317667974"),
+	}, {
+		Name:  "SqrtE",
+		Const: floatFromGo("1.64872127070012814684865078781416357165377610071014801157507931"),
+	}, {
+		Name:  "SqrtPi",
+		Const: floatFromGo("1.77245385090551602729816748334114518279754945612238712821380779"),
+	}, {
+		Name:  "SqrtPhi",
+		Const: floatFromGo("1.27201964951406896425242246173749149171560804184009624861664038"),
+	}, {
+		Name:  "Ln2",
+		Const: floatFromGo("0.693147180559945309417232121458176568075500134360255254120680009"),
+	}, {
+		Name:  "Log2E",
+		Const: floatFromGo("1.442695040888963407359924681001892137426645954152985934135449408"),
+	}, {
+		Name:  "Ln10",
+		Const: floatFromGo("2.3025850929940456840179914546843642076011014886287729760333278"),
+	}, {
+		Name:  "Log10E",
+		Const: floatFromGo("0.43429448190325182765112891891660508229439700580366656611445378"),
+	}, {
+		Name:   "Copysign",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x, y := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Copysign(x, y)
+			}()
+		},
+	}, {
+		Name:   "Dim",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x, y := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Dim(x, y)
+			}()
+		},
+	}, {
+		Name:   "Erf",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Erf(x)
+			}()
+		},
+	}, {
+		Name:   "Erfc",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Erfc(x)
+			}()
+		},
+	}, {
+		Name:   "Erfinv",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Erfinv(x)
+			}()
+		},
+	}, {
+		Name:   "Erfcinv",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Erfcinv(x)
+			}()
+		},
+	}, {
+		Name:   "Exp",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Exp(x)
+			}()
+		},
+	}, {
+		Name:   "Exp2",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Exp2(x)
+			}()
+		},
+	}, {
+		Name:   "Expm1",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Expm1(x)
+			}()
+		},
+	}, {
+		Name:   "Gamma",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Gamma(x)
+			}()
+		},
+	}, {
+		Name:   "Hypot",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			p, q := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Hypot(p, q)
+			}()
+		},
+	}, {
+		Name:   "J0",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.J0(x)
+			}()
+		},
+	}, {
+		Name:   "Y0",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Y0(x)
+			}()
+		},
+	}, {
+		Name:   "J1",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.J1(x)
+			}()
+		},
+	}, {
+		Name:   "Y1",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Y1(x)
+			}()
+		},
+	}, {
+		Name:   "Jn",
+		Params: []kind{intKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			n, x := c.int(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Jn(n, x)
+			}()
+		},
+	}, {
+		Name:   "Yn",
+		Params: []kind{intKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			n, x := c.int(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Yn(n, x)
+			}()
+		},
+	}, {
+		Name:   "Ldexp",
+		Params: []kind{numKind, intKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			frac, exp := c.float64(0), c.int(1)
+			c.ret = func() interface{} {
+				return math.Ldexp(frac, exp)
+			}()
+		},
+	}, {
+		Name:   "Log",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Log(x)
+			}()
+		},
+	}, {
+		Name:   "Log10",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Log10(x)
+			}()
+		},
+	}, {
+		Name:   "Log2",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Log2(x)
+			}()
+		},
+	}, {
+		Name:   "Log1p",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Log1p(x)
+			}()
+		},
+	}, {
+		Name:   "Logb",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Logb(x)
+			}()
+		},
+	}, {
+		Name:   "Ilogb",
+		Params: []kind{numKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Ilogb(x)
+			}()
+		},
+	}, {
+		Name:   "Mod",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x, y := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Mod(x, y)
+			}()
+		},
+	}, {
+		Name:   "Pow",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x, y := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Pow(x, y)
+			}()
+		},
+	}, {
+		Name:   "Pow10",
+		Params: []kind{intKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			n := c.int(0)
+			c.ret = func() interface{} {
+				return math.Pow10(n)
+			}()
+		},
+	}, {
+		Name:   "Remainder",
+		Params: []kind{numKind, numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x, y := c.float64(0), c.float64(1)
+			c.ret = func() interface{} {
+				return math.Remainder(x, y)
+			}()
+		},
+	}, {
+		Name:   "Signbit",
+		Params: []kind{numKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Signbit(x)
+			}()
+		},
+	}, {
+		Name:   "Cos",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Cos(x)
+			}()
+		},
+	}, {
+		Name:   "Sin",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Sin(x)
+			}()
+		},
+	}, {
+		Name:   "Sinh",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Sinh(x)
+			}()
+		},
+	}, {
+		Name:   "Cosh",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Cosh(x)
+			}()
+		},
+	}, {
+		Name:   "Sqrt",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Sqrt(x)
+			}()
+		},
+	}, {
+		Name:   "Tan",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Tan(x)
+			}()
+		},
+	}, {
+		Name:   "Tanh",
+		Params: []kind{numKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			x := c.float64(0)
+			c.ret = func() interface{} {
+				return math.Tanh(x)
+			}()
+		},
+	}},
+	"math/bits": []*builtin{{
+		Name:   "And",
+		Params: []kind{intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			a, b := c.bigInt(0), c.bigInt(1)
+			c.ret = func() interface{} {
+				wa := a.Bits()
+				wb := b.Bits()
+				n := len(wa)
+				if len(wb) < n {
+					n = len(wb)
+				}
+				w := make([]big.Word, n)
+				for i := range w {
+					w[i] = wa[i] & wb[i]
+				}
+				i := &big.Int{}
+				i.SetBits(w)
+				return i
+			}()
+		},
+	}, {
+		Name:   "Or",
+		Params: []kind{intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			a, b := c.bigInt(0), c.bigInt(1)
+			c.ret = func() interface{} {
+				wa := a.Bits()
+				wb := b.Bits()
+				var w []big.Word
+				n := len(wa)
+				if len(wa) > len(wb) {
+					w = append(w, wa...)
+					n = len(wb)
+				} else {
+					w = append(w, wb...)
+				}
+				for i := 0; i < n; i++ {
+					w[i] = wa[i] | wb[i]
+				}
+				i := &big.Int{}
+				i.SetBits(w)
+				return i
+			}()
+		},
+	}, {
+		Name:   "Xor",
+		Params: []kind{intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			a, b := c.bigInt(0), c.bigInt(1)
+			c.ret = func() interface{} {
+				wa := a.Bits()
+				wb := b.Bits()
+				var w []big.Word
+				n := len(wa)
+				if len(wa) > len(wb) {
+					w = append(w, wa...)
+					n = len(wb)
+				} else {
+					w = append(w, wb...)
+				}
+				for i := 0; i < n; i++ {
+					w[i] = wa[i] ^ wb[i]
+				}
+				i := &big.Int{}
+				i.SetBits(w)
+				return i
+			}()
+		},
+	}, {
+		Name:   "Clear",
+		Params: []kind{intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			a, b := c.bigInt(0), c.bigInt(1)
+			c.ret = func() interface{} {
+				wa := a.Bits()
+				wb := b.Bits()
+				w := append([]big.Word(nil), wa...)
+				for i, m := range wb {
+					if i >= len(w) {
+						break
+					}
+					w[i] = wa[i] &^ m
+				}
+				i := &big.Int{}
+				i.SetBits(w)
+				return i
+			}()
+		},
+	}, {
+		Name:   "OnesCount",
+		Params: []kind{intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x := c.uint64(0)
+			c.ret = func() interface{} {
+				return bits.OnesCount64(x)
+			}()
+		},
+	}, {
+		Name:   "RotateLeft",
+		Params: []kind{intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x, k := c.uint64(0), c.int(1)
+			c.ret = func() interface{} {
+				return bits.RotateLeft64(x, k)
+			}()
+		},
+	}, {
+		Name:   "Reverse",
+		Params: []kind{intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x := c.uint64(0)
+			c.ret = func() interface{} {
+				return bits.Reverse64(x)
+			}()
+		},
+	}, {
+		Name:   "ReverseBytes",
+		Params: []kind{intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x := c.uint64(0)
+			c.ret = func() interface{} {
+				return bits.ReverseBytes64(x)
+			}()
+		},
+	}, {
+		Name:   "Len",
+		Params: []kind{intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			x := c.uint64(0)
+			c.ret = func() interface{} {
+				return bits.Len64(x)
+			}()
+		},
+	}},
+	"path": []*builtin{{
+		Name:   "Split",
+		Params: []kind{stringKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			path := c.string(0)
+			c.ret = func() interface{} {
+				file, dir := split(path)
+				return []string{file, dir}
+			}()
+		},
+	}, {
+		Name:   "Match",
+		Params: []kind{stringKind, stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			pattern, name := c.string(0), c.string(1)
+			c.ret, c.err = func() (interface{}, error) {
+				return path.Match(pattern, name)
+			}()
+		},
+	}, {
+		Name:   "Clean",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			path := c.string(0)
+			c.ret = func() interface{} {
+				return pathClean(path)
+			}()
+		},
+	}, {
+		Name:   "Ext",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			path := c.string(0)
+			c.ret = func() interface{} {
+				return pathExt(path)
+			}()
+		},
+	}, {
+		Name:   "Base",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			path := c.string(0)
+			c.ret = func() interface{} {
+				return pathBase(path)
+			}()
+		},
+	}, {
+		Name:   "IsAbs",
+		Params: []kind{stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			path := c.string(0)
+			c.ret = func() interface{} {
+				return pathIsAbs(path)
+			}()
+		},
+	}, {
+		Name:   "Dir",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			path := c.string(0)
+			c.ret = func() interface{} {
+				return pathDir(path)
+			}()
+		},
+	}},
+	"regexp": []*builtin{{
+		Name:   "Match",
+		Params: []kind{stringKind, stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			pattern, s := c.string(0), c.string(1)
+			c.ret, c.err = func() (interface{}, error) {
+				return regexp.MatchString(pattern, s)
+			}()
+		},
+	}, {
+		Name:   "QuoteMeta",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return regexp.QuoteMeta(s)
+			}()
+		},
+	}},
+	"runtime": []*builtin{{
+		Name:   "Path",
+		Params: []kind{},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			c.ret = func() interface{} {
+				return ""
+			}()
+		},
+	}},
+	"strconv": []*builtin{{
+		Name:   "Unquote",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret, c.err = func() (interface{}, error) {
+				return Unquote(s)
+			}()
+		},
+	}, {
+		Name:   "ParseBool",
+		Params: []kind{stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			str := c.string(0)
+			c.ret, c.err = func() (interface{}, error) {
+				return strconv.ParseBool(str)
+			}()
+		},
+	}, {
+		Name:   "FormatBool",
+		Params: []kind{boolKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			b := c.bool(0)
+			c.ret = func() interface{} {
+				return strconv.FormatBool(b)
+			}()
+		},
+	}, {
+		Name:   "ParseFloat",
+		Params: []kind{stringKind, intKind},
+		Result: numKind,
+		Func: func(c *callCtxt) {
+			s, bitSize := c.string(0), c.int(1)
+			c.ret, c.err = func() (interface{}, error) {
+				return strconv.ParseFloat(s, bitSize)
+			}()
+		},
+	}, {
+		Name:  "IntSize",
+		Const: intFromGo("64"),
+	}, {
+		Name:   "ParseUint",
+		Params: []kind{stringKind, intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, base, bitSize := c.string(0), c.int(1), c.int(2)
+			c.ret, c.err = func() (interface{}, error) {
+				return strconv.ParseUint(s, base, bitSize)
+			}()
+		},
+	}, {
+		Name:   "ParseInt",
+		Params: []kind{stringKind, intKind, intKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, base, bitSize := c.string(0), c.int(1), c.int(2)
+			c.ret, c.err = func() (interface{}, error) {
+				return strconv.ParseInt(s, base, bitSize)
+			}()
+		},
+	}, {
+		Name:   "Atoi",
+		Params: []kind{stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret, c.err = func() (interface{}, error) {
+				return strconv.Atoi(s)
+			}()
+		},
+	}, {
+		Name:   "FormatFloat",
+		Params: []kind{numKind, intKind, intKind, intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			f, fmt, prec, bitSize := c.float64(0), c.byte(1), c.int(2), c.int(3)
+			c.ret = func() interface{} {
+				return strconv.FormatFloat(f, fmt, prec, bitSize)
+			}()
+		},
+	}, {
+		Name:   "FormatUint",
+		Params: []kind{intKind, intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			i, base := c.uint64(0), c.int(1)
+			c.ret = func() interface{} {
+				return strconv.FormatUint(i, base)
+			}()
+		},
+	}, {
+		Name:   "FormatInt",
+		Params: []kind{intKind, intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			i, base := c.int64(0), c.int(1)
+			c.ret = func() interface{} {
+				return strconv.FormatInt(i, base)
+			}()
+		},
+	}, {
+		Name:   "Quote",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strconv.Quote(s)
+			}()
+		},
+	}, {
+		Name:   "QuoteToASCII",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strconv.QuoteToASCII(s)
+			}()
+		},
+	}, {
+		Name:   "QuoteToGraphic",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strconv.QuoteToGraphic(s)
+			}()
+		},
+	}, {
+		Name:   "QuoteRune",
+		Params: []kind{intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			r := c.rune(0)
+			c.ret = func() interface{} {
+				return strconv.QuoteRune(r)
+			}()
+		},
+	}, {
+		Name:   "QuoteRuneToASCII",
+		Params: []kind{intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			r := c.rune(0)
+			c.ret = func() interface{} {
+				return strconv.QuoteRuneToASCII(r)
+			}()
+		},
+	}, {
+		Name:   "QuoteRuneToGraphic",
+		Params: []kind{intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			r := c.rune(0)
+			c.ret = func() interface{} {
+				return strconv.QuoteRuneToGraphic(r)
+			}()
+		},
+	}, {
+		Name:   "CanBackquote",
+		Params: []kind{stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strconv.CanBackquote(s)
+			}()
+		},
+	}, {
+		Name:   "IsPrint",
+		Params: []kind{intKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			r := c.rune(0)
+			c.ret = func() interface{} {
+				return strconv.IsPrint(r)
+			}()
+		},
+	}, {
+		Name:   "IsGraphic",
+		Params: []kind{intKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			r := c.rune(0)
+			c.ret = func() interface{} {
+				return strconv.IsGraphic(r)
+			}()
+		},
+	}},
+	"strings": []*builtin{{
+		Name:   "ToTitle",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+
+				prev := ' '
+				return strings.Map(
+					func(r rune) rune {
+						if unicode.IsSpace(prev) {
+							prev = r
+							return unicode.ToTitle(r)
+						}
+						prev = r
+						return r
+					},
+					s)
+			}()
+		},
+	}, {
+		Name:   "ToCamel",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+
+				prev := ' '
+				return strings.Map(
+					func(r rune) rune {
+						if unicode.IsSpace(prev) {
+							prev = r
+							return unicode.ToLower(r)
+						}
+						prev = r
+						return r
+					},
+					s)
+			}()
+		},
+	}, {
+		Name:   "Compare",
+		Params: []kind{stringKind, stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			a, b := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.Compare(a, b)
+			}()
+		},
+	}, {
+		Name:   "Count",
+		Params: []kind{stringKind, stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, substr := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.Count(s, substr)
+			}()
+		},
+	}, {
+		Name:   "Contains",
+		Params: []kind{stringKind, stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			s, substr := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.Contains(s, substr)
+			}()
+		},
+	}, {
+		Name:   "ContainsAny",
+		Params: []kind{stringKind, stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			s, chars := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.ContainsAny(s, chars)
+			}()
+		},
+	}, {
+		Name:   "LastIndex",
+		Params: []kind{stringKind, stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, substr := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.LastIndex(s, substr)
+			}()
+		},
+	}, {
+		Name:   "IndexAny",
+		Params: []kind{stringKind, stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, chars := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.IndexAny(s, chars)
+			}()
+		},
+	}, {
+		Name:   "LastIndexAny",
+		Params: []kind{stringKind, stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, chars := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.LastIndexAny(s, chars)
+			}()
+		},
+	}, {
+		Name:   "SplitN",
+		Params: []kind{stringKind, stringKind, intKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			s, sep, n := c.string(0), c.string(1), c.int(2)
+			c.ret = func() interface{} {
+				return strings.SplitN(s, sep, n)
+			}()
+		},
+	}, {
+		Name:   "SplitAfterN",
+		Params: []kind{stringKind, stringKind, intKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			s, sep, n := c.string(0), c.string(1), c.int(2)
+			c.ret = func() interface{} {
+				return strings.SplitAfterN(s, sep, n)
+			}()
+		},
+	}, {
+		Name:   "Split",
+		Params: []kind{stringKind, stringKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			s, sep := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.Split(s, sep)
+			}()
+		},
+	}, {
+		Name:   "SplitAfter",
+		Params: []kind{stringKind, stringKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			s, sep := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.SplitAfter(s, sep)
+			}()
+		},
+	}, {
+		Name:   "Fields",
+		Params: []kind{stringKind},
+		Result: listKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strings.Fields(s)
+			}()
+		},
+	}, {
+		Name:   "Join",
+		Params: []kind{listKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			a, sep := c.strList(0), c.string(1)
+			if c.do() {
+				c.ret = func() interface{} {
+					return strings.Join(a, sep)
+				}()
+			}
+		},
+	}, {
+		Name:   "HasPrefix",
+		Params: []kind{stringKind, stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			s, prefix := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.HasPrefix(s, prefix)
+			}()
+		},
+	}, {
+		Name:   "HasSuffix",
+		Params: []kind{stringKind, stringKind},
+		Result: boolKind,
+		Func: func(c *callCtxt) {
+			s, suffix := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.HasSuffix(s, suffix)
+			}()
+		},
+	}, {
+		Name:   "Repeat",
+		Params: []kind{stringKind, intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, count := c.string(0), c.int(1)
+			c.ret = func() interface{} {
+				return strings.Repeat(s, count)
+			}()
+		},
+	}, {
+		Name:   "ToUpper",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strings.ToUpper(s)
+			}()
+		},
+	}, {
+		Name:   "ToLower",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strings.ToLower(s)
+			}()
+		},
+	}, {
+		Name:   "Trim",
+		Params: []kind{stringKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, cutset := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.Trim(s, cutset)
+			}()
+		},
+	}, {
+		Name:   "TrimLeft",
+		Params: []kind{stringKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, cutset := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.TrimLeft(s, cutset)
+			}()
+		},
+	}, {
+		Name:   "TrimRight",
+		Params: []kind{stringKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, cutset := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.TrimRight(s, cutset)
+			}()
+		},
+	}, {
+		Name:   "TrimSpace",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return strings.TrimSpace(s)
+			}()
+		},
+	}, {
+		Name:   "TrimPrefix",
+		Params: []kind{stringKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, prefix := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.TrimPrefix(s, prefix)
+			}()
+		},
+	}, {
+		Name:   "TrimSuffix",
+		Params: []kind{stringKind, stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, suffix := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.TrimSuffix(s, suffix)
+			}()
+		},
+	}, {
+		Name:   "Replace",
+		Params: []kind{stringKind, stringKind, stringKind, intKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s, old, new, n := c.string(0), c.string(1), c.string(2), c.int(3)
+			c.ret = func() interface{} {
+				return strings.Replace(s, old, new, n)
+			}()
+		},
+	}, {
+		Name:   "Index",
+		Params: []kind{stringKind, stringKind},
+		Result: intKind,
+		Func: func(c *callCtxt) {
+			s, substr := c.string(0), c.string(1)
+			c.ret = func() interface{} {
+				return strings.Index(s, substr)
+			}()
+		},
+	}},
+	"text/tabwriter": []*builtin{{
+		Name:   "Write",
+		Params: []kind{topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			data := c.value(0)
+			c.ret, c.err = func() (interface{}, error) {
+				buf := &bytes.Buffer{}
+				tw := tabwriter.NewWriter(buf, 0, 4, 1, ' ', 0)
+				b, err := data.Bytes()
+				if err != nil {
+					return "", err
+				}
+				_, err = tw.Write(b)
+				if err != nil {
+					return "", err
+				}
+				return buf.String(), err
+			}()
+		},
+	}},
+	"text/template": []*builtin{{
+		Name:   "Execute",
+		Params: []kind{stringKind, topKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			templ, data := c.string(0), c.value(1)
+			c.ret, c.err = func() (interface{}, error) {
+				t, err := template.New("").Parse(templ)
+				if err != nil {
+					return "", err
+				}
+				buf := &bytes.Buffer{}
+				if err := t.Execute(buf, data); err != nil {
+					return "", err
+				}
+				return buf.String(), nil
+			}()
+		},
+	}, {
+		Name:   "HTMLEscape",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return template.HTMLEscapeString(s)
+			}()
+		},
+	}, {
+		Name:   "JSEscape",
+		Params: []kind{stringKind},
+		Result: stringKind,
+		Func: func(c *callCtxt) {
+			s := c.string(0)
+			c.ret = func() interface{} {
+				return template.JSEscapeString(s)
+			}()
+		},
+	}},
+}
diff --git a/cue/export_test.go b/cue/export_test.go
index 9eda831..1b8701a 100644
--- a/cue/export_test.go
+++ b/cue/export_test.go
@@ -145,6 +145,14 @@
 				a: 0..10
 				b: "Count: \(a) times"
 			}`),
+	}, {
+		raw: true,
+		in:  `{ a: "", b: len(a) }`,
+		out: unindent(`
+				{
+					a: ""
+					b: len(a)
+				}`),
 	}}
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
diff --git a/cue/gen.go b/cue/gen.go
new file mode 100644
index 0000000..7effb9a
--- /dev/null
+++ b/cue/gen.go
@@ -0,0 +1,400 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build ignore
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/format"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"log"
+	"math/big"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+const prefix = "../pkg/"
+
+const header = `// Code generated by go generate. DO NOT EDIT.
+
+package cue
+
+`
+
+const initFunc = `
+func init() {
+	initBuiltins(builtinPackages)
+}
+
+var _ io.Reader
+`
+
+func main() {
+	flag.Parse()
+	log.SetFlags(log.Lshortfile)
+	log.SetOutput(os.Stdout)
+
+	g := generator{
+		w:     &bytes.Buffer{},
+		decls: &bytes.Buffer{},
+		fset:  token.NewFileSet(),
+	}
+
+	fmt.Fprintln(g.w, "var builtinPackages = map[string][]*builtin{")
+	filepath.Walk(prefix, func(dir string, info os.FileInfo, err error) error {
+		if err != nil {
+			log.Fatal(err)
+		}
+		if info.Name() == "testdata" {
+			return filepath.SkipDir
+		}
+		if info.IsDir() {
+			g.processDir(dir)
+		}
+		return nil
+	})
+	fmt.Fprintln(g.w, "}")
+
+	w := &bytes.Buffer{}
+	fmt.Fprintln(w, header)
+
+	m := map[string]*ast.ImportSpec{}
+	keys := []string{}
+	for _, spec := range g.imports {
+		if spec.Path.Value == `"cuelang.org/go/cue"` {
+			// Don't add this package.
+			continue
+		}
+		if prev, ok := m[spec.Path.Value]; ok {
+			if importName(prev) != importName(spec) {
+				log.Fatalf("inconsistent name for import %s: %q != %q",
+					spec.Path.Value, importName(prev), importName(spec))
+			}
+			continue
+		}
+		m[spec.Path.Value] = spec
+		keys = append(keys, spec.Path.Value)
+	}
+	fmt.Fprintln(w, "import (")
+	sort.Strings(keys)
+	for _, k := range keys {
+		printer.Fprint(w, g.fset, m[k])
+		fmt.Fprintln(w)
+	}
+	fmt.Fprintln(w, ")")
+	fmt.Fprintln(w, initFunc)
+	io.Copy(w, g.decls)
+	io.Copy(w, g.w)
+
+	b, err := format.Source(w.Bytes())
+	if err != nil {
+		b = w.Bytes() // write the unformatted source
+	}
+	// TODO: do this in a more principled way. The best is probably to
+	// put all builtins in a separate package.
+	b = bytes.Replace(b, []byte("cue."), []byte(""), -1)
+
+	if err := ioutil.WriteFile("builtins.go", b, 0644); err != nil {
+		log.Fatal(err)
+	}
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+type generator struct {
+	w          *bytes.Buffer
+	decls      *bytes.Buffer
+	fset       *token.FileSet
+	defaultPkg string
+	first      bool
+	iota       int
+
+	imports []*ast.ImportSpec
+}
+
+func (g *generator) processDir(dir string) {
+	args, err := filepath.Glob(filepath.Join(dir, "*.go"))
+	if err != nil {
+		log.Fatal(err)
+	}
+	if len(args) == 0 {
+		return
+	}
+	pkg := dir[len(prefix):]
+	fmt.Fprintf(g.w, "%q: []*builtin{{\n", pkg)
+	defer fmt.Fprintf(g.w, "}},\n")
+	g.first = true
+	for _, filename := range args {
+		g.process(filename)
+	}
+}
+
+func (g *generator) sep() {
+	if g.first {
+		g.first = false
+		return
+	}
+	fmt.Fprintln(g.w, "}, {")
+}
+
+func importName(s *ast.ImportSpec) string {
+	if s.Name != nil {
+		return s.Name.Name
+	}
+	pkg, err := strconv.Unquote(s.Path.Value)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return path.Base(pkg)
+}
+
+func (g *generator) process(filename string) {
+	f, err := parser.ParseFile(g.fset, filename, nil, parser.ParseComments)
+	if err != nil {
+		log.Fatal(err)
+	}
+	g.defaultPkg = ""
+
+	for _, d := range f.Decls {
+		switch x := d.(type) {
+		case *ast.GenDecl:
+			switch x.Tok {
+			case token.CONST:
+				for _, spec := range x.Specs {
+					g.genConst(spec.(*ast.ValueSpec))
+				}
+			case token.IMPORT:
+				for _, s := range x.Specs {
+					spec := s.(*ast.ImportSpec)
+					g.imports = append(g.imports, spec)
+				}
+				if g.defaultPkg == "" {
+					g.defaultPkg = importName(x.Specs[0].(*ast.ImportSpec))
+				}
+			case token.VAR:
+				for _, spec := range x.Specs {
+					if ast.IsExported(spec.(*ast.ValueSpec).Names[0].Name) {
+						log.Fatal("var declarations not supported")
+					}
+				}
+				printer.Fprint(g.decls, g.fset, x)
+				fmt.Fprint(g.decls, "\n\n")
+				continue
+			case token.TYPE:
+				for _, spec := range x.Specs {
+					if ast.IsExported(spec.(*ast.TypeSpec).Name.Name) {
+						log.Fatal("type declarations not supported")
+					}
+				}
+				printer.Fprint(g.decls, g.fset, x)
+				fmt.Fprint(g.decls, "\n\n")
+				continue
+			default:
+				log.Fatalf("unexpected spec of type %s", x.Tok)
+			}
+		case *ast.FuncDecl:
+			g.genFun(x)
+		}
+	}
+}
+
+func (g *generator) genConst(spec *ast.ValueSpec) {
+	name := spec.Names[0].Name
+	value := ""
+	switch v := g.toValue(spec.Values[0]); v.Kind() {
+	case constant.Bool:
+		value = fmt.Sprintf("&boolList{b: %q}", v.String())
+	case constant.String:
+		value = fmt.Sprintf("&stringLit{str: %q}", v.ExactString())
+	case constant.Int:
+		value = fmt.Sprintf("intFromGo(%q)", v.ExactString())
+	case constant.Float:
+		var rat big.Rat
+		rat.SetString(v.ExactString())
+		var float big.Float
+		float.SetRat(&rat)
+		value = fmt.Sprintf("floatFromGo(%q)", float.Text('g', -1))
+	default:
+		fmt.Printf("Dropped entry %s.%s (%T: %v)\n", g.defaultPkg, name, v.Kind(), v.ExactString())
+		return
+	}
+	g.sep()
+	fmt.Fprintf(g.w, "Name: %q,\n Const: %s,\n", name, value)
+}
+
+func (g *generator) toValue(x ast.Expr) constant.Value {
+	switch x := x.(type) {
+	case *ast.BasicLit:
+		return constant.MakeFromLiteral(x.Value, x.Kind, 0)
+	case *ast.BinaryExpr:
+		return constant.BinaryOp(g.toValue(x.X), x.Op, g.toValue(x.Y))
+	case *ast.UnaryExpr:
+		return constant.UnaryOp(x.Op, g.toValue(x.X), 0)
+	default:
+		log.Fatalf("%s: unsupported expression type %T: %#v", g.defaultPkg, x, x)
+	}
+	return constant.MakeUnknown()
+}
+
+func (g *generator) genFun(x *ast.FuncDecl) {
+	if x.Body == nil {
+		return
+	}
+	types := []string{}
+	if x.Type.Results != nil {
+		for _, f := range x.Type.Results.List {
+			if len(f.Names) > 0 {
+				for range f.Names {
+					types = append(types, g.goKind(f.Type))
+				}
+			} else {
+				types = append(types, g.goKind(f.Type))
+			}
+		}
+	}
+	if n := len(types); n != 1 && (n != 2 || types[1] != "error") {
+		fmt.Printf("Dropped func %s.%s: must have one return value or a value and an error %v\n", g.defaultPkg, x.Name.Name, types)
+	}
+
+	g.sep()
+	fmt.Fprintf(g.w, "Name: %q,\n", x.Name.Name)
+
+	args := []string{}
+	vals := []string{}
+	kind := []string{}
+	omitCheck := true
+	for _, f := range x.Type.Params.List {
+		for _, name := range f.Names {
+			typ := g.goKind(f.Type)
+			argKind, ground := g.goToCUE(f.Type)
+			if !ground {
+				omitCheck = false
+			}
+			vals = append(vals, fmt.Sprintf("c.%s(%d)", typ, len(args)))
+			args = append(args, name.Name)
+			kind = append(kind, argKind)
+		}
+	}
+
+	fmt.Fprintf(g.w, "Params: []kind{%s},\n", strings.Join(kind, ", "))
+	result, _ := g.goToCUE(x.Type.Results.List[0].Type)
+	fmt.Fprintf(g.w, "Result: %s,\n", result)
+	argList := strings.Join(args, ", ")
+	valList := strings.Join(vals, ", ")
+	init := ""
+	if len(args) > 0 {
+		init = fmt.Sprintf("%s := %s", argList, valList)
+	}
+
+	fmt.Fprintf(g.w, "Func: func(c *callCtxt) {")
+	defer fmt.Fprintln(g.w, "},")
+	fmt.Fprintln(g.w)
+	if init != "" {
+		fmt.Fprintln(g.w, init)
+	}
+	if !omitCheck {
+		fmt.Fprintln(g.w, "if c.do() {")
+		defer fmt.Fprintln(g.w, "}")
+	}
+	if len(types) == 1 {
+		fmt.Fprint(g.w, "c.ret = func() interface{} ")
+	} else {
+		fmt.Fprint(g.w, "c.ret, c.err = func() (interface{}, error) ")
+	}
+	printer.Fprint(g.w, g.fset, x.Body)
+	fmt.Fprintln(g.w, "()")
+}
+
+func (g *generator) goKind(expr ast.Expr) string {
+	if star, isStar := expr.(*ast.StarExpr); isStar {
+		expr = star.X
+	}
+	w := &bytes.Buffer{}
+	printer.Fprint(w, g.fset, expr)
+	switch str := w.String(); str {
+	case "big.Int":
+		return "bigInt"
+	case "big.Float":
+		return "bigFloat"
+	case "big.Rat":
+		return "bigRat"
+	case "cue.Value":
+		return "value"
+	case "cue.List":
+		return "list"
+	case "[]string":
+		return "strList"
+	case "[]byte":
+		return "bytes"
+	case "io.Reader":
+		return "reader"
+	default:
+		return str
+	}
+}
+
+func (g *generator) goToCUE(expr ast.Expr) (cueKind string, omitCheck bool) {
+	// TODO: detect list and structs types for return values.
+	omitCheck = true
+	switch k := g.goKind(expr); k {
+	case "error":
+		cueKind += "bottomKind"
+	case "bool":
+		cueKind += "boolKind"
+	case "string", "bytes", "reader":
+		cueKind += "stringKind"
+	case "int", "int8", "int16", "int32", "rune", "int64",
+		"uint", "byte", "uint8", "uint16", "uint32", "uint64",
+		"bigInt":
+		cueKind += "intKind"
+	case "float64", "bigRat", "bigFloat":
+		cueKind += "numKind"
+	case "list":
+		cueKind += "listKind"
+	case "strList":
+		omitCheck = false
+		cueKind += "listKind"
+	case "value":
+		// Must use callCtxt.value method for these types and resolve manually.
+		cueKind += "topKind" // TODO: can be more precise
+	default:
+		switch {
+		case strings.HasPrefix(k, "[]"):
+			cueKind += "listKind"
+		case strings.HasPrefix(k, "map["):
+			cueKind += "structKind"
+		default:
+			// log.Println("Unknown type:", k)
+			// Must use callCtxt.value method for these types and resolve manually.
+			cueKind += "topKind" // TODO: can be more precise
+			omitCheck = false
+		}
+	}
+	return cueKind, omitCheck
+}
diff --git a/pkg/math/manual.go b/pkg/math/manual.go
new file mode 100644
index 0000000..493f8c5
--- /dev/null
+++ b/pkg/math/manual.go
@@ -0,0 +1,69 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package math
+
+import "math"
+
+// TODO: use apd
+
+// Floor returns the greatest integer value less than or equal to x.
+//
+// Special cases are:
+//	Floor(±0) = ±0
+//	Floor(±Inf) = ±Inf
+//	Floor(NaN) = NaN
+func Floor(x float64) float64 {
+	return math.Floor(x)
+}
+
+// Ceil returns the least integer value greater than or equal to x.
+//
+// Special cases are:
+//	Ceil(±0) = ±0
+//	Ceil(±Inf) = ±Inf
+//	Ceil(NaN) = NaN
+func Ceil(x float64) float64 {
+	return math.Ceil(x)
+}
+
+// Trunc returns the integer value of x.
+//
+// Special cases are:
+//	Trunc(±0) = ±0
+//	Trunc(±Inf) = ±Inf
+//	Trunc(NaN) = NaN
+func Trunc(x float64) float64 {
+	return math.Trunc(x)
+}
+
+// Round returns the nearest integer, rounding half away from zero.
+//
+// Special cases are:
+//	Round(±0) = ±0
+//	Round(±Inf) = ±Inf
+//	Round(NaN) = NaN
+func Round(x float64) float64 {
+	return math.Round(x)
+}
+
+// RoundToEven returns the nearest integer, rounding ties to even.
+//
+// Special cases are:
+//	RoundToEven(±0) = ±0
+//	RoundToEven(±Inf) = ±Inf
+//	RoundToEven(NaN) = NaN
+func RoundToEven(x float64) float64 {
+	return math.RoundToEven(x)
+}